BigNum Math Implementing Cryptographic Multiple Precision Arithmetic
Tom St Denis LibTom Projects
Greg Rose QUALCOMM Australia
Syngress Publishing, Inc., the author(s), and any person or firm involved in the writing, editing, or production (collectively “Makers”) of this book (“the Work”) do not guarantee or warrant the results to be obtained from the Work. There is no guarantee of any kind, expressed or implied, regarding the Work or its contents. The Work is sold AS IS and WITHOUT WARRANTY. You may have other legal rights, which vary from state to state. In no event will Makers be liable to you for damages, including any loss of profits, lost savings, or other incidental or consequential damages arising out from the Work or its contents. Because some states do not allow the exclusion or limitation of liability for consequential or incidental damages, the above limitation may not apply to you. You should always use reasonable care, including backup and other appropriate precautions, when working with computers, networks, data, and files. R Syngress , R “Career Advancement Through Skill Enhancement ,” R Syngress Media , R R “Ask the Author UPDATE ,” and “Hack Proofing ,” are registered trademarks of Syngress Publishing, Inc. “‘Syngress: The Definition of a Serious Security LibraryTM ”, “Mission CriticalTM ,” and “The Only Way to Stop a Hacker is to Think Like OneTM ” are trademarks of Syngress Publishing, Inc. Brands and product names mentioned in this book are trademarks or service marks of their respective companies.
KEY 001 002 003 004 005 006 007 008 009 010
SERIAL NUMBER HJIRTCV764 PO9873D5FG 829KM8NJH2 HJ9899923N CVPLQ6WQ23 VBP965T5T5 HJJJ863WD3E 2987GVTWMK 629MP5SDJT IMWQ295T6T
PUBLISHED BY Syngress Publishing, Inc. 800 Hingham Street Rockland, MA 02370 BigNum Math: Implementing Cryptographic Multiple Precision Arithmetic
c 2006 by Syngress Publishing, Inc. All rights reserved. Printed in Canada. Copyright Except as permitted under the Copyright Act of 1976, no part of this publication may be reproduced or distributed in any form or by any means, or stored in a database or retrieval system, without the prior written permission of the publisher, with the exception that the program listings may be entered, stored, and executed in a computer system, but they may not be reproduced for publication. Printed in the United States of America 1234567890 ISBN: 1597491128 Publisher: Andrew Williams Copy Editor: Beth Roberts
Page Layout and Art: Tom St Denis Cover Designer: Michael Kavish
Distributed by O’Reilly Media, Inc. in the United States and Canada. For information on rights, translations, and bulk sales, contact Matt Pedersen, Director of Sales and Rights, at Syngress Publishing; email
[email protected] or fax to 781-681-3585.
Contents Preface
xv
1 Introduction 1.1 Multiple Precision Arithmetic . . . . . . . . . . . . 1.1.1 What Is Multiple Precision Arithmetic? . . 1.1.2 The Need for Multiple Precision Arithmetic 1.1.3 Benefits of Multiple Precision Arithmetic . 1.2 Purpose of This Text . . . . . . . . . . . . . . . . . 1.3 Discussion and Notation . . . . . . . . . . . . . . . 1.3.1 Notation . . . . . . . . . . . . . . . . . . . . 1.3.2 Precision Notation . . . . . . . . . . . . . . 1.3.3 Algorithm Inputs and Outputs . . . . . . . 1.3.4 Mathematical Expressions . . . . . . . . . . 1.3.5 Work Effort . . . . . . . . . . . . . . . . . . 1.4 Exercises . . . . . . . . . . . . . . . . . . . . . . . 1.5 Introduction to LibTomMath . . . . . . . . . . . . 1.5.1 What Is LibTomMath? . . . . . . . . . . . 1.5.2 Goals of LibTomMath . . . . . . . . . . . . 1.6 Choice of LibTomMath . . . . . . . . . . . . . . . 1.6.1 Code Base . . . . . . . . . . . . . . . . . . . 1.6.2 API Simplicity . . . . . . . . . . . . . . . . 1.6.3 Optimizations . . . . . . . . . . . . . . . . . 1.6.4 Portability and Stability . . . . . . . . . . . 1.6.5 Choice . . . . . . . . . . . . . . . . . . . . .
1 1 1 2 3 4 5 5 5 6 6 7 7 9 9 9 10 10 11 11 12 12
v
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
2 Getting Started 2.1 Library Basics . . . . . . . . . . . . . . . . . . . . . 2.2 What Is a Multiple Precision Integer? . . . . . . . . 2.2.1 The mp int Structure . . . . . . . . . . . . . 2.3 Argument Passing . . . . . . . . . . . . . . . . . . . 2.4 Return Values . . . . . . . . . . . . . . . . . . . . . . 2.5 Initialization and Clearing . . . . . . . . . . . . . . . 2.5.1 Initializing an mp int . . . . . . . . . . . . . 2.5.2 Clearing an mp int . . . . . . . . . . . . . . . 2.6 Maintenance Algorithms . . . . . . . . . . . . . . . . 2.6.1 Augmenting an mp int’s Precision . . . . . . 2.6.2 Initializing Variable Precision mp ints . . . . 2.6.3 Multiple Integer Initializations and Clearings 2.6.4 Clamping Excess Digits . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
13 13 14 15 17 18 19 19 22 24 24 27 29 31
3 Basic Operations 3.1 Introduction . . . . . . . . . . . . . . . 3.2 Assigning Values to mp int Structures 3.2.1 Copying an mp int . . . . . . . 3.2.2 Creating a Clone . . . . . . . . 3.3 Zeroing an Integer . . . . . . . . . . . 3.4 Sign Manipulation . . . . . . . . . . . 3.4.1 Absolute Value . . . . . . . . . 3.4.2 Integer Negation . . . . . . . . 3.5 Small Constants . . . . . . . . . . . . 3.5.1 Setting Small Constants . . . . 3.5.2 Setting Large Constants . . . . 3.6 Comparisons . . . . . . . . . . . . . . 3.6.1 Unsigned Comparisons . . . . . 3.6.2 Signed Comparisons . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . .
35 35 35 35 39 41 42 42 43 44 44 46 47 47 50
4 Basic Arithmetic 4.1 Introduction . . . . . . . . . . . 4.2 Addition and Subtraction . . . 4.2.1 Low Level Addition . . 4.2.2 Low Level Subtraction . 4.2.3 High Level Addition . . 4.2.4 High Level Subtraction
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
53 53 54 54 59 63 66
. . . . . .
. . . . . .
. . . . . .
. . . . . .
4.3
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
69 69 72 75 75 78 81 82 85 88
5 Multiplication and Squaring 5.1 The Multipliers . . . . . . . . . . . . . . . . . . . . . . 5.2 Multiplication . . . . . . . . . . . . . . . . . . . . . . . 5.2.1 The Baseline Multiplication . . . . . . . . . . . 5.2.2 Faster Multiplication by the “Comba” Method 5.2.3 Even Faster Multiplication . . . . . . . . . . . 5.2.4 Polynomial Basis Multiplication . . . . . . . . 5.2.5 Karatsuba Multiplication . . . . . . . . . . . . 5.2.6 Toom-Cook 3-Way Multiplication . . . . . . . . 5.2.7 Signed Multiplication . . . . . . . . . . . . . . 5.3 Squaring . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3.1 The Baseline Squaring Algorithm . . . . . . . . 5.3.2 Faster Squaring by the “Comba” Method . . . 5.3.3 Even Faster Squaring . . . . . . . . . . . . . . 5.3.4 Polynomial Basis Squaring . . . . . . . . . . . 5.3.5 Karatsuba Squaring . . . . . . . . . . . . . . . 5.3.6 Toom-Cook Squaring . . . . . . . . . . . . . . . 5.3.7 High Level Squaring . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
91 91 92 92 97 104 107 109 116 126 128 129 133 137 138 138 143 144
6 Modular Reduction 6.1 Basics of Modular Reduction . 6.2 The Barrett Reduction . . . . . 6.2.1 Fixed Point Arithmetic 6.2.2 Choosing a Radix Point 6.2.3 Trimming the Quotient 6.2.4 Trimming the Residue . 6.2.5 The Barrett Algorithm .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
147 147 148 148 150 151 152 153
4.4
4.5
Bit and Digit Shifting . . . . . . . . . . . 4.3.1 Multiplication by Two . . . . . . . 4.3.2 Division by Two . . . . . . . . . . Polynomial Basis Operations . . . . . . . 4.4.1 Multiplication by x . . . . . . . . . 4.4.2 Division by x . . . . . . . . . . . . Powers of Two . . . . . . . . . . . . . . . 4.5.1 Multiplication by Power of Two . . 4.5.2 Division by Power of Two . . . . . 4.5.3 Remainder of Division by Power of
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . Two
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . . . . .
. . . . . . .
. . . . . . . . . .
. . . . . . .
. . . . . . . . . .
. . . . . . .
. . . . . . .
6.3
6.4
6.5
6.2.6 The Barrett Setup Algorithm . . . . . . . The Montgomery Reduction . . . . . . . . . . . . 6.3.1 Digit Based Montgomery Reduction . . . 6.3.2 Baseline Montgomery Reduction . . . . . 6.3.3 Faster “Comba” Montgomery Reduction . 6.3.4 Montgomery Setup . . . . . . . . . . . . . The Diminished Radix Algorithm . . . . . . . . . 6.4.1 Choice of Moduli . . . . . . . . . . . . . . 6.4.2 Choice of k . . . . . . . . . . . . . . . . . 6.4.3 Restricted Diminished Radix Reduction . 6.4.4 Unrestricted Diminished Radix Reduction Algorithm Comparison . . . . . . . . . . . . . . .
7 Exponentiation 7.1 Exponentiation Basics . . . . . . . . . . 7.1.1 Single Digit Exponentiation . . . 7.2 k-ary Exponentiation . . . . . . . . . . . 7.2.1 Optimal Values of k . . . . . . . 7.2.2 Sliding Window Exponentiation . 7.3 Modular Exponentiation . . . . . . . . . 7.3.1 Barrett Modular Exponentiation 7.4 Quick Power of Two . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
156 158 160 162 167 173 175 177 178 178 184 189
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
191 191 193 195 196 197 198 203 214
8 Higher Level Algorithms 8.1 Integer Division with Remainder . . . . . . . 8.1.1 Quotient Estimation . . . . . . . . . . 8.1.2 Normalized Integers . . . . . . . . . . 8.1.3 Radix-β Division with Remainder . . 8.2 Single Digit Helpers . . . . . . . . . . . . . . 8.2.1 Single Digit Addition and Subtraction 8.2.2 Single Digit Multiplication . . . . . . 8.2.3 Single Digit Division . . . . . . . . . . 8.2.4 Single Digit Root Extraction . . . . . 8.3 Random Number Generation . . . . . . . . . 8.4 Formatted Representations . . . . . . . . . . 8.4.1 Reading Radix-n Input . . . . . . . . 8.4.2 Generating Radix-n Output . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . .
217 217 219 220 221 231 232 235 237 241 245 247 247 252
. . . . . . . .
. . . . . . . .
9 Number Theoretic Algorithms 9.1 Greatest Common Divisor . . . . . . . . . . 9.1.1 Complete Greatest Common Divisor 9.2 Least Common Multiple . . . . . . . . . . . 9.3 Jacobi Symbol Computation . . . . . . . . . 9.3.1 Jacobi Symbol . . . . . . . . . . . . 9.4 Modular Inverse . . . . . . . . . . . . . . . 9.4.1 General Case . . . . . . . . . . . . . 9.5 Primality Tests . . . . . . . . . . . . . . . . 9.5.1 Trial Division . . . . . . . . . . . . . 9.5.2 The Fermat Test . . . . . . . . . . . 9.5.3 The Miller-Rabin Test . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
255 255 258 263 265 266 271 273 279 279 282 284
Bibliography
289
Index
291
List of Figures 1.1 1.2
Typical Data Types for the C Programming Language . . . . . . . Exercise Scoring System . . . . . . . . . . . . . . . . . . . . . . . .
2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9
Design Flow of the First Few Original LibTomMath Functions. The mp int Structure . . . . . . . . . . . . . . . . . . . . . . . LibTomMath Error Codes . . . . . . . . . . . . . . . . . . . . . Algorithm mp init . . . . . . . . . . . . . . . . . . . . . . . . . Algorithm mp clear . . . . . . . . . . . . . . . . . . . . . . . . . Algorithm mp grow . . . . . . . . . . . . . . . . . . . . . . . . . Algorithm mp init size . . . . . . . . . . . . . . . . . . . . . . . Algorithm mp init multi . . . . . . . . . . . . . . . . . . . . . . Algorithm mp clamp . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . .
. . . . . . . . .
14 16 18 20 22 25 27 29 31
3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10
Algorithm mp copy . . . . Algorithm mp init copy . Algorithm mp zero . . . . Algorithm mp abs . . . . Algorithm mp neg . . . . Algorithm mp set . . . . . Algorithm mp set int . . . Comparison Return Codes Algorithm mp cmp mag . Algorithm mp cmp . . . .
. . . . . . . . . .
. . . . . . . . . .
36 40 41 42 43 45 46 48 48 50
4.1 4.2 4.3
Algorithm s mp add . . . . . . . . . . . . . . . . . . . . . . . . . . Algorithm s mp sub . . . . . . . . . . . . . . . . . . . . . . . . . . Algorithm mp add . . . . . . . . . . . . . . . . . . . . . . . . . . .
55 60 64
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
xi
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
2 8
4.4 4.5 4.6 4.7 4.8 4.9 4.10 4.11 4.12 4.13 4.14
Addition Guide Chart . . . Algorithm mp sub . . . . . Subtraction Guide Chart . . Algorithm mp mul 2 . . . . Algorithm mp div 2 . . . . Algorithm mp lshd . . . . . Sliding Window Movement Algorithm mp rshd . . . . . Algorithm mp mul 2d . . . Algorithm mp div 2d . . . . Algorithm mp mod 2d . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
65 67 67 70 73 76 77 79 82 85 88
5.1 5.2 5.3 5.4 5.5 5.6 5.7 5.8 5.9 5.10 5.11 5.12 5.13 5.14 5.15
Algorithm s mp mul digs . . . . . . . . . . . . . . . . . . . . Long-Hand Multiplication Diagram . . . . . . . . . . . . . . . Comba Multiplication Diagram . . . . . . . . . . . . . . . . . Algorithm Comba Fixup . . . . . . . . . . . . . . . . . . . . . Algorithm fast s mp mul digs . . . . . . . . . . . . . . . . . . Algorithm fast mult . . . . . . . . . . . . . . . . . . . . . . . Asymptotic Running Time of Polynomial Basis Multiplication Algorithm mp karatsuba mul . . . . . . . . . . . . . . . . . . Algorithm mp toom mul . . . . . . . . . . . . . . . . . . . . . Algorithm mp mul . . . . . . . . . . . . . . . . . . . . . . . . Squaring Optimization Diagram . . . . . . . . . . . . . . . . . Algorithm s mp sqr . . . . . . . . . . . . . . . . . . . . . . . . Algorithm fast s mp sqr . . . . . . . . . . . . . . . . . . . . . Algorithm mp karatsuba sqr . . . . . . . . . . . . . . . . . . . Algorithm mp sqr . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
93 94 98 98 100 105 108 111 118 126 128 130 134 139 144
6.1 6.2 6.3 6.4 6.5 6.6 6.7 6.8 6.9 6.10
Algorithm mp reduce . . . . . . . . . . . . . . . . Algorithm mp reduce setup . . . . . . . . . . . . Algorithm Montgomery Reduction . . . . . . . . Example of Montgomery Reduction (I) . . . . . . Algorithm Montgomery Reduction (modified I) . Example of Montgomery Reduction (II) . . . . . Algorithm Montgomery Reduction (modified II) . Example of Montgomery Reduction . . . . . . . . Algorithm mp montgomery reduce . . . . . . . . Algorithm fast mp montgomery reduce . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
153 157 158 159 159 160 161 161 163 168
. . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
6.11 6.12 6.13 6.14 6.15 6.16 6.17 6.18 6.19
Algorithm mp montgomery setup . . . . Algorithm Diminished Radix Reduction Example Diminished Radix Reduction . Algorithm mp dr reduce . . . . . . . . . Algorithm mp dr setup . . . . . . . . . Algorithm mp dr is modulus . . . . . . Algorithm mp reduce 2k . . . . . . . . . Algorithm mp reduce 2k setup . . . . . Algorithm mp reduce is 2k . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
174 176 177 179 182 183 184 186 188
7.1 7.2 7.3 7.4 7.5 7.6 7.7 7.8 7.9 7.10 7.11
Left to Right Exponentiation . . . . . . . . . . . . . . . Example of Left to Right Exponentiation . . . . . . . . Algorithm mp expt d . . . . . . . . . . . . . . . . . . . . k-ary Exponentiation . . . . . . . . . . . . . . . . . . . . Optimal Values of k for k-ary Exponentiation . . . . . . Optimal Values of k for Sliding Window Exponentiation Sliding Window k-ary Exponentiation . . . . . . . . . . Algorithm mp exptmod . . . . . . . . . . . . . . . . . . Algorithm s mp exptmod . . . . . . . . . . . . . . . . . Sliding Window State Diagram . . . . . . . . . . . . . . Algorithm mp 2expt . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
192 193 194 196 197 197 198 199 205 207 214
8.1 8.2 8.3 8.4 8.5 8.6 8.7 8.8 8.9 8.10 8.11
Algorithm Radix-β Integer Division Algorithm mp div . . . . . . . . . . Algorithm mp add d . . . . . . . . . Algorithm mp mul d . . . . . . . . . Algorithm mp div d . . . . . . . . . Algorithm mp n root . . . . . . . . . Algorithm mp rand . . . . . . . . . . Lower ASCII Map . . . . . . . . . . Algorithm mp read radix . . . . . . Algorithm mp toradix . . . . . . . . Example of Algorithm mp toradix. .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
218 223 232 235 238 242 246 248 249 252 253
9.1 9.2 9.3 9.4
Algorithm Algorithm Algorithm Algorithm
(I) . (II) (III) . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
256 256 257 259
Greatest Greatest Greatest mp gcd
Common Divisor Common Divisor Common Divisor . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
9.5 9.6 9.7 9.8 9.9 9.10
Algorithm Algorithm Algorithm Algorithm Algorithm Algorithm
mp mp mp mp mp mp
lcm . . . . . . . . jacobi . . . . . . . invmod . . . . . . prime is divisible . prime fermat . . . prime miller rabin
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
263 268 274 280 283 285
Preface The origins of this book are part of an interesting period of my life. A period that saw me move from a shy and disorganized young adult, into a software developer who has toured various parts of the world, and met countless new friends and colleagues. It all began in December of 2001, nearly five years ago. I started a project that would later become known as LibTomCrypt, and be used by developers throughout industry worldwide. The LibTomCrypt project was originally started as a way to focus my energies on to something constructive, while also learning new skills. The first year of the project taught me quite a bit about how to organize a product, document and support it and maintain it over time. Around the winter of 2002 I was seeking another project to spread my time with. Realizing that the math performance of LibTomCrypt was lacking, I set out to develop a new math library. Hence, the LibTomMath project was born. It was originally merely a set of patches against an existing project that quickly grew into a project of its own. Writing the math library from scratch was fundamental to producing a stable and independent product. It also taught me what sort of algorithms are available to do operations such as modular exponentiation. The library became fairly stable and reliable after only a couple of months of development and was immediately put to use. In the summer of 2003, I was yet again looking for another project to grow into. Realizing that merely implementing the math routines is not enough to truly understand them, I set out to try and explain them myself. In doing so, I eventually mastered the concepts behind the algorithms. This knowledge is what I hope will be passed on to the reader. This text is actually derived from the public domain archives I maintain on my www.libtomcrypt.com Web site. When I tell people about my LibTom projects (of which there are six) and that I release them as public domain, they are often puzzled. They ask why I xv
xvi
www.syngress.com
did it, and especially why I continue to work on them for free. The best I can explain it is, “Because I can”–which seems odd and perhaps too terse for adult conversation. I often qualify it with “I am able, I am willing,” which perhaps explains it better. I am the first to admit there is nothing that special with what I have done. Perhaps others can see that, too, and then we would have a society to be proud of. My LibTom projects are what I am doing to give back to society in the form of tools and knowledge that can help others in their endeavors. I started writing this book because it was the most logical task to further my goal of open academia. The LibTomMath source code itself was written to be easy to follow and learn from. There are times, however, where pure C source code does not explain the algorithms properly–hence this book. The book literally starts with the foundation of the library and works itself outward to the more complicated algorithms. The use of both pseudo–code and verbatim source code provides a duality of “theory” and “practice” the computer science students of the world shall appreciate. I never deviate too far from relatively straightforward algebra, and I hope this book can be a valuable learning asset. This book, and indeed much of the LibTom projects, would not exist in its current form if it were not for a plethora of kind people donating their time, resources, and kind words to help support my work. Writing a text of significant length (along with the source code) is a tiresome and lengthy process. Currently, the LibTom project is five years old, composed of literally thousands of users and over 100,000 lines of source code, TEX, and other material. People like Mads Rassmussen and Greg Rose were there at the beginning to encourage me to work well. It is amazing how timely validation from others can boost morale to continue the project. Definitely, my parents were there for me by providing room and board during the many months of work in 2003. Both Greg and Mads were invaluable sources of support in the early stages of this project. The initial draft of this text, released in August 2003, was the project of several months of dedicated work. Long hours and still going to school were a constant drain of energy that would not have lasted without support. Of course this book would not be here if it were not for the success of the various LibTom projects. That success is not only the product of my hard work, but also the contribution of hundreds of other people. People like Colin Percival, Sky Schultz, Wayne Scott, J Harper, Dan Kaminsky, Lance James, Simon Johnson, Greg Rose, Clay Culver, Jochen Katz, Zhi Chen, Zed Shaw, Andrew Mann, Matt Johnston, Steven Dake, Richard Amacker, Stefan Arentz, Richard Outerbridge, Martin Carpenter, Craig Schlenter, John Kuhns, Bruce Guenter, Adam Miller, Wesley Shields, John Dirk, Jean–Luc Cooke, Michael Heyman, Nelson Bolyard,
Preface
xvii
Jim Wigginton, Don Porter, Kevin Kenny, Peter LaDow, Neal Hamilton, David Hulton, Paul Schmidt, Wolfgang Ehrhardt, Johan Lindt, Henrik Goldman, Alex Polushin, Martin Marcel, Brian Gladman, Benjamin Goldberg, Tom Wu, and Pekka Riikonen took their time to contribute ideas, updates, fixes, or encouragement throughout the various project development phases. To my many friends whom I have met through the years, I thank you for the good times and the words of encouragement. I hope I honor your kind gestures with this project. I’d like to thank the editing team at Syngress for poring over 300 pages of text and correcting it in the short span of a single week. I’d like to thank my friends whom I have not mentioned, who were always available for encouragement and a steady supply of fun. I’d like to thank my friends J Harper, Zed Shaw, and Simon Johnson for reviewing the text before submission. I’d like to thank Lance James of the Secure Science Corporation and the entire crew at Elliptic Semiconductor for sponsoring much of my later development time, for sending me to Toorcon, and introducing me to many of the people whom I know today. Open Source. Open Academia. Open Minds. Tom St Denis Toronto, Canada May 2006
xviii
www.syngress.com
It’s all because I broke my leg. That just happened to be about the same time Tom asked for someone to review the section of the book about Karatsuba multiplication. I was laid up, alone and immobile, and thought, “Why not?” I vaguely knew what Karatsuba multiplication was, but not really, so I thought I could help, learn, and stop myself from watching daytime cable TV, all at once. At the time of writing this, I’ve still not met Tom or Mads in meatspace. I’ve been following Tom’s progress since his first splash on the sci.crypt Usenet newsgroup. I watched him go from a clueless newbie, to the cryptographic equivalent of a reformed smoker, to a real contributor to the field, over a period of about two years. I’ve been impressed with his obvious intelligence, and astounded by his productivity. Of course, he’s young enough to be my own child, so he doesn’t have my problems with staying awake. When I reviewed that single section of the book, in its earliest form, I was very pleasantly surprised. So I decided to collaborate more fully, and at least review all of it, and perhaps write some bits, too. There’s still a long way to go with it, and I have watched a number of close friends go through the mill of publication, so I think the way to go is longer than Tom thinks it is. Nevertheless, it’s a good effort, and I’m pleased to be involved with it. Greg Rose Sydney, Australia June 2003
Chapter 1
Introduction 1.1 1.1.1
Multiple Precision Arithmetic What Is Multiple Precision Arithmetic?
When we think of long-hand arithmetic such as addition or multiplication, we rarely consider the fact that we instinctively raise or lower the precision of the numbers we are dealing with. For example, in decimal we almost immediately can reason that 7 times 6 is 42. However, 42 has two digits of precision as opposed to the one digit we started with. Further multiplications of say 3 result in a larger precision result 126. In these few examples we have multiple precisions for the numbers we are working with. Despite the various levels of precision, a single subset1 of algorithms can be designed to accommodate them. By way of comparison, a fixed or single precision operation would lose precision on various operations. For example, in the decimal system with fixed precision 6 · 7 = 2.
Essentially, at the heart of computer–based multiple precision arithmetic are the same long-hand algorithms taught in schools to manually add, subtract, multiply, and divide. 1 With
the occasional optimization.
1
2
1.1.2
www.syngress.com
The Need for Multiple Precision Arithmetic
The most prevalent need for multiple precision arithmetic, often referred to as “bignum” math, is within the implementation of public key cryptography algorithms. Algorithms such as RSA [10] and Diffie-Hellman [11] require integers of significant magnitude to resist known cryptanalytic attacks. For example, at the time of this writing a typical RSA modulus would be at least greater than 10309 . However, modern programming languages such as ISO C [17] and Java [18] only provide intrinsic support for integers that are relatively small and single precision. Data Type char short long long long
Range −128 . . . 127 −32768 . . . 32767 −2147483648 . . . 2147483647 −9223372036854775808 . . .9223372036854775807
Figure 1.1: Typical Data Types for the C Programming Language The largest data type guaranteed to be provided by the ISO C programming language2 can only represent values up to 1019 as shown in Figure 1.1. On its own, the C language is insufficient to accommodate the magnitude required for the problem at hand. An RSA modulus of magnitude 1019 could be trivially factored3 on the average desktop computer, rendering any protocol based on the algorithm insecure. Multiple precision algorithms solve this problem by extending the range of representable integers while using single precision data types. Most advancements in fast multiple precision arithmetic stem from the need for faster and more efficient cryptographic primitives. Faster modular reduction and exponentiation algorithms such as Barrett’s reduction algorithm, which have appeared in various cryptographic journals, can render algorithms such as RSA and Diffie-Hellman more efficient. In fact, several major companies such as RSA Security, Certicom, and Entrust have built entire product lines on the implementation and deployment of efficient algorithms. However, cryptography is not the only field of study that can benefit from fast multiple precision integer routines. Another auxiliary use of multiple precision integers is high precision floating point data types. The basic IEEE [12] standard 2 As per the ISO C standard. However, each compiler vendor is allowed to augment the precision as they see fit. 3 A Pollard-Rho factoring would take only 216 time.
1.1 Multiple Precision Arithmetic
3
floating point type is made up of an integer mantissa q, an exponent e, and a sign bit s. Numbers are given in the form n = q · be · −1s , where b = 2 is the most common base for IEEE. Since IEEE floating point is meant to be implemented in hardware, the precision of the mantissa is often fairly small (23, 48, and 64 bits). The mantissa is merely an integer, and a multiple precision integer could be used to create a mantissa of much larger precision than hardware alone can efficiently support. This approach could be useful where scientific applications must minimize the total output error over long calculations. Yet another use for large integers is within arithmetic on polynomials of large characteristic (i.e., GF (p)[x] for large p). In fact, the library discussed within this text has already been used to form a polynomial basis library4 .
1.1.3
Benefits of Multiple Precision Arithmetic
The benefit of multiple precision representations over single or fixed precision representations is that no precision is lost while representing the result of an operation that requires excess precision. For example, the product of two nbit integers requires at least 2n bits of precision to be represented faithfully. A multiple precision algorithm would augment the precision of the destination to accommodate the result, while a single precision system would truncate excess bits to maintain a fixed level of precision. It is possible to implement algorithms that require large integers with fixed precision algorithms. For example, elliptic curve cryptography (ECC ) is often implemented on smartcards by fixing the precision of the integers to the maximum size the system will ever need. Such an approach can lead to vastly simpler algorithms that can accommodate the integers required even if the host platform cannot natively accommodate them5 . However, as efficient as such an approach may be, the resulting source code is not normally very flexible. It cannot, at run time, accommodate inputs of higher magnitude than the designer anticipated. Multiple precision algorithms have the most overhead of any style of arithmetic. For the the most part the overhead can be kept to a minimum with careful planning, but overall, it is not well suited for most memory starved platforms. However, multiple precision algorithms do offer the most flexibility in terms of the magnitude of the inputs. That is, the same algorithms based on multiple precision integers can accommodate any reasonable size input without the designer’s 4 See 5 For
http://poly.libtomcrypt.org for more details. example, the average smartcard processor has an 8–bit accumulator.
4
www.syngress.com
explicit forethought. This leads to lower cost of ownership for the code, as it only has to be written and tested once.
1.2
Purpose of This Text
The purpose of this text is to instruct the reader regarding how to implement efficient multiple precision algorithms. That is, to explain a limited subset of the core theory behind the algorithms, and the various “housekeeping” elements that are neglected by authors of other texts on the subject. Several texts [1, 2] give considerably detailed explanations of the theoretical aspects of algorithms and often very little information regarding the practical implementation aspects. In most cases, how an algorithm is explained and how it is actually implemented are two very different concepts. For example, the Handbook of Applied Cryptography (HAC ), algorithm 14.7 on page 594, gives a relatively simple algorithm for performing multiple precision integer addition. However, the description lacks any discussion concerning the fact that the two integer inputs may be of differing magnitudes. As a result, the implementation is not as simple as the text would lead people to believe. Similarly, the division routine (algorithm 14.20, pp. 598 ) does not discuss how to handle sign or the dividend’s decreasing magnitude in the main loop (step #3 ). Both texts also do not discuss several key optimal algorithms required, such as “Comba” and Karatsuba multipliers and fast modular inversion, which we consider practical oversights. These optimal algorithms are vital to achieve any form of useful performance in non–trivial applications. To solve this problem, the focus of this text is on the practical aspects of implementing a multiple precision integer package. As a case study, the “LibTomMath”6 package is used to demonstrate algorithms with real implementations7 that have been field tested and work very well. The LibTomMath library is freely available on the Internet for all uses, and this text discusses a very large portion of the inner workings of the library. The algorithms presented will always include at least one “pseudo-code” description followed by the actual C source code that implements the algorithm. The pseudo-code can be used to implement the same algorithm in other programming languages as the reader sees fit. 6 Available 7 In
at http://math.libtomcrypt.com the ISO C programming language.
1.3 Discussion and Notation
5
This text shall also serve as a walk-through of the creation of multiple precision algorithms from scratch, showing the reader how the algorithms fit together and where to start on various taskings.
1.3 1.3.1
Discussion and Notation Notation
A multiple precision integer of n-digits shall be denoted as x = (xn−1 , . . . , x1 , x0 )β Pn−1 and represent the integer x ≡ i=0 xi β i . The elements of the array x are said to be the radix β digits of the integer. For example, x = (1, 2, 3)10 would represent the integer 1 · 102 + 2 · 101 + 3 · 100 = 123. The term “mp int” shall refer to a composite structure that contains the digits of the integer it represents, and auxiliary data required to manipulate the data. These additional members are discussed further in section 2.2.1. For the purposes of this text, a “multiple precision integer” and an “mp int” are assumed synonymous. When an algorithm is specified to accept an mp int variable, it is assumed the various auxiliary data members are present as well. An expression of the type variablename.item implies that it should evaluate to the member named “item” of the variable. For example, a string of characters may have a member “length” that would evaluate to the number of characters in the string. If the string a equals hello, then it follows that a.length = 5. For certain discussions, more generic algorithms are presented to help the reader understand the final algorithm used to solve a given problem. When an algorithm is described as accepting an integer input, it is assumed the input is a plain integer with no additional multiple precision members. That is, algorithms that use integers as opposed to mp ints as inputs do not concern themselves with the housekeeping operations required such as memory management. These algorithms will be used to establish the relevant theory that will subsequently be used to describe a multiple precision algorithm to solve the same problem.
1.3.2
Precision Notation
The variable β represents the radix of a single digit of a multiple precision integer and must be of the form q p for q, p ∈ Z+ . A single precision variable must be able to represent integers in the range 0 ≤ x < qβ, while a double precision variable must be able to represent integers in the range 0 ≤ x < qβ 2 . The extra radix-
6
www.syngress.com
q factor allows additions and subtractions to proceed without truncation of the carry. Since all modern computers are binary, it is assumed that q is two. Within the source code that will be presented for each algorithm, the data type mp digit will represent a single precision integer type, while the data type mp word will represent a double precision integer type. In several algorithms (notably the Comba routines), temporary results will be stored in arrays of double precision mp words. For the purposes of this text, xj will refer to the j’th digit of a single precision array, and x ˆj will refer to the j’th digit of a double precision array. Whenever an expression is to be assigned to a double precision variable, it is assumed that all single precision variables are promoted to double precision during the evaluation. Expressions that are assigned to a single precision variable are truncated to fit within the precision of a single precision data type. For example, if β = 102 , a single precision data type may represent a value in the range 0 ≤ x < 103 , while a double precision data type may represent a value in the range 0 ≤ x < 105 . Let a = 23 and b = 49 represent two single precision variables. The single precision product shall be written as c ← a · b, while the double precision product shall be written as cˆ ← a · b. In this particular case, cˆ = 1127 and c = 127. The most significant digit of the product would not fit in a single precision data type and as a result c 6= cˆ.
1.3.3
Algorithm Inputs and Outputs
Within the algorithm descriptions all variables are assumed scalars of either single or double precision as indicated. The only exception to this rule is when variables have been indicated to be of type mp int. This distinction is important, as scalars are often used as array indicies and various other counters.
1.3.4
Mathematical Expressions
The ⌊ ⌋ brackets imply an expression truncated to an integer not greater than the expression itself; for example, ⌊5.7⌋ = 5. Similarly, the ⌈ ⌉ brackets imply an expression rounded to an integer not less than the expression itself; for example, ⌈5.1⌉ = 6. Typically, when the / division symbol is used, the intention is to perform an integer division with truncation; for example, 5/2 = 2, which will often be written as ⌊5/2⌋ = 2 for clarity. When an expression is written as a fraction a real value division is implied; for example, 25 = 2.5. The norm of a multiple precision integer, for example ||x||, will be used to represent the number of digits in the representation of the integer; for example,
1.4 Exercises
7
||123|| = 3 and ||79452|| = 5.
1.3.5
Work Effort
To measure the efficiency of the specified algorithms, a modified big-Oh notation is used. In this system, all single precision operations are considered to have the same cost8 . That is, a single precision addition, multiplication, and division are assumed to take the same time to complete. While this is generally not true in practice, it will simplify the discussions considerably. Some algorithms have slight advantages over others, which is why some constants will not be removed in the notation. For example, a normal baseline multiplication (section 5.2.1) requires O(n2 ) work, while a baseline squaring (section 2 5.3) requires O( n 2+n ) work. In standard big-Oh notation, these would both be said to be equivalent to O(n2 ). However, in the context of this text, this is not the case, as the magnitude of the inputs will typically be rather small. As a result, small constant factors in the work effort will make an observable difference in algorithm efficiency. All algorithms presented in this text have a polynomial time work level; that is, of the form O(nk ) for n, k ∈ Z+ . This will help make useful comparisons in terms of the speed of the algorithms and how various optimizations will help pay off in the long run.
1.4
Exercises
Within the more advanced chapters a section is set aside to give the reader some challenging exercises related to the discussion at hand. These exercises are not designed to be prize–winning problems, but instead to be thought provoking. Wherever possible the problems are forward minded, stating problems that will be answered in subsequent chapters. The reader is encouraged to finish the exercises as they appear to get a better understanding of the subject material. That being said, the problems are designed to affirm knowledge of a particular subject matter. Students in particular are encouraged to verify they can answer the problems correctly before moving on. Similar to the exercises as described in [1, pp. ix], these exercises are given a scoring system based on the difficulty of the problem. However, unlike [1], the problems do not get nearly as hard. The scoring of these exercises ranges from 8 Except
where explicitly noted.
8
www.syngress.com
one (the easiest) to five (the hardest). Figure 1.2 summarizes the scoring system used. [1]
[2]
[3]
[4]
[5]
An easy problem that should only take the reader a manner of minutes to solve. Usually does not involve much computer time to solve. An easy problem that involves a marginal amount of computer time usage. Usually requires a program to be written to solve the problem. A moderately hard problem that requires a non-trivial amount of work. Usually involves trivial research and development of new theory from the perspective of a student. A moderately hard problem that involves a non-trivial amount of work and research, the solution to which will demonstrate a higher mastery of the subject matter. A hard problem that involves concepts that are difficult for a novice to solve. Solutions to these problems will demonstrate a complete mastery of the given subject.
Figure 1.2: Exercise Scoring System Problems at the first level are meant to be simple questions the reader can answer quickly without programming a solution or devising new theory. These problems are quick tests to see if the material is understood. Problems at the second level are also designed to be easy, but will require a program or algorithm to be implemented to arrive at the answer. These two levels are essentially entry level questions. Problems at the third level are meant to be a bit more difficult than the first two levels. The answer is often fairly obvious, but arriving at an exacting solution requires some thought and skill. These problems will almost always involve devising a new algorithm or implementing a variation of another algorithm previously presented. Readers who can answer these questions will feel comfortable with the concepts behind the topic at hand. Problems at the fourth level are meant to be similar to those of the level–three questions except they will require additional research to be completed. The reader will most likely not know the answer right away, nor will the text provide the exact details of the answer until a subsequent chapter. Problems at the fifth level are meant to be the hardest problems relative to all the other problems in the chapter. People who can correctly answer fifth–level
1.5 Introduction to LibTomMath
9
problems have a mastery of the subject matter at hand. Often problems will be tied together. The purpose of this is to start a chain of thought that will be discussed in future chapters. The reader is encouraged to answer the follow-up problems and try to draw the relevance of problems.
1.5 1.5.1
Introduction to LibTomMath What Is LibTomMath?
LibTomMath is a free and open source multiple precision integer library written entirely in portable ISO C. By portable it is meant that the library does not contain any code that is computer platform dependent or otherwise problematic to use on any given platform. The library has been successfully tested under numerous operating systems, including Unix9 , Mac OS, Windows, Linux, Palm OS, and on standalone hardware such as the Gameboy Advance. The library is designed to contain enough functionality to be able to develop applications such as public key cryptosystems and still maintain a relatively small footprint.
1.5.2
Goals of LibTomMath
Libraries that obtain the most efficiency are rarely written in a high level programming language such as C. However, even though this library is written entirely in ISO C, considerable care has been taken to optimize the algorithm implementations within the library. Specifically, the code has been written to work well with the GNU C Compiler (GCC ) on both x86 and ARM processors. Wherever possible, highly efficient algorithms, such as Karatsuba multiplication, sliding window exponentiation, and Montgomery reduction have been provided to make the library more efficient. Even with the nearly optimal and specialized algorithms that have been included, the application programing interface (API ) has been kept as simple as possible. Often, generic placeholder routines will make use of specialized algorithms automatically without the developer’s specific attention. One such example is the generic multiplication algorithm mp mul(), which will automatically use Toom– Cook, Karatsuba, Comba, or baseline multiplication based on the magnitude of the inputs and the configuration of the library. 9 All
of these trademarks belong to their respective rightful owners.
10
www.syngress.com
Making LibTomMath as efficient as possible is not the only goal of the LibTomMath project. Ideally, the library should be source compatible with another popular library, which makes it more attractive for developers to use. In this case, the MPI library was used as an API template for all the basic functions. MPI was chosen because it is another library that fits in the same niche as LibTomMath. Even though LibTomMath uses MPI as the template for the function names and argument passing conventions, it has been written from scratch by Tom St Denis. The project is also meant to act as a learning tool for students, the logic being that no easy-to-follow “bignum” library exists that can be used to teach computer science students how to perform fast and reliable multiple precision integer arithmetic. To this end, the source code has been given quite a few comments and algorithm discussion points.
1.6
Choice of LibTomMath
LibTomMath was chosen as the case study of this text not only because the author of both projects is one and the same, but for more worthy reasons. Other libraries such as GMP [13], MPI [14], LIP [16], and OpenSSL [15] have multiple precision integer arithmetic routines but would not be ideal for this text for reasons that will be explained in the following sub-sections.
1.6.1
Code Base
The LibTomMath code base is all portable ISO C source code. This means that there are no platform–dependent conditional segments of code littered throughout the source. This clean and uncluttered approach to the library means that a developer can more readily discern the true intent of a given section of source code without trying to keep track of what conditional code will be used. The code base of LibTomMath is well organized. Each function is in its own separate source code file, which allows the reader to find a given function very quickly. On average there are 76 lines of code per source file, which makes the source very easily to follow. By comparison, MPI and LIP are single file projects making code tracing very hard. GMP has many conditional code segments segments that also hinder tracing. When compiled with GCC for the x86 processor and optimized for speed, the entire library is approximately 100KiB10, which is fairly small compared to GMP 10 The
notation “KiB” means 210 octets, similarly “MiB” means 220 octets.
1.6 Choice of LibTomMath
11
(over 250KiB). LibTomMath is slightly larger than MPI (which compiles to about 50KiB), but is also much faster and more complete than MPI.
1.6.2
API Simplicity
LibTomMath is designed after the MPI library and shares the API design. Quite often, programs that use MPI will build with LibTomMath without change. The function names correlate directly to the action they perform. Almost all of the functions share the same parameter passing convention. The learning curve is fairly shallow with the API provided, which is an extremely valuable benefit for the student and developer alike. The LIP library is an example of a library with an API that is awkward to work with. LIP uses function names that are often “compressed” to illegible shorthand. LibTomMath does not share this characteristic. The GMP library also does not return error codes. Instead, it uses a POSIX.1 signal system where errors are signaled to the host application. This happens to be the fastest approach, but definitely not the most versatile. In effect, a math error (i.e., invalid input, heap error, etc.) can cause a program to stop functioning, which is definitely undesirable in many situations.
1.6.3
Optimizations
While LibTomMath is certainly not the fastest library (GMP often beats LibTomMath by a factor of two), it does feature a set of optimal algorithms for tasks such as modular reduction, exponentiation, multiplication, and squaring. GMP and LIP also feature such optimizations, while MPI only uses baseline algorithms with no optimizations. GMP lacks a few of the additional modular reduction optimizations that LibTomMath features11 . LibTomMath is almost always an order of magnitude faster than the MPI library at computationally expensive tasks such as modular exponentiation. In the grand scheme of “bignum” libraries, LibTomMath is faster than the average library and usually slower than the best libraries such as GMP and OpenSSL by only a small factor. 11 At the time of this writing, GMP only had Barrett and Montgomery modular reduction algorithms.
12
www.syngress.com
New Developments Since the writing of the original manuscript, a new project, TomsFastMath, has been created. It is directly derived from LibTomMath, with a major focus on multiplication, squaring, and reduction performance. It relaxes the portability requirements to use inline assembly for performance. Readers are encouraged to check out this project at http://tfm.libtomcrypt.com to see how far performance can go with the code in this book.
1.6.4
Portability and Stability
LibTomMath will build “out of the box” on any platform equipped with a modern version of the GNU C Compiler (GCC ). This means that without changes the library will build without configuration or setting up any variables. LIP and MPI will build “out of the box” as well but have numerous known bugs. Most notably, the author of MPI has recently stopped working on his library, and LIP has long since been discontinued. GMP requires a configuration script to run and will not build out of the box. GMP and LibTomMath are still in active development and are very stable across a variety of platforms.
1.6.5
Choice
LibTomMath is a relatively compact, well–documented, highly optimized, and portable library, which seems only natural for the case study of this text. Various source files from the LibTomMath project will be included within the text. However, readers are encouraged to download their own copies of the library to actually be able to work with the library.
Chapter 2
Getting Started 2.1
Library Basics
The trick to writing any useful library of source code is to build a solid foundation and work outward from it. First, a problem along with allowable solution parameters should be identified and analyzed. In this particular case, the inability to accommodate multiple precision integers is the problem. Furthermore, the solution must be written as portable source code that is reasonably efficient across several different computer platforms. After a foundation is formed, the remainder of the library can be designed and implemented in a hierarchical fashion. That is, to implement the lowest level dependencies first and work toward the most abstract functions last. For example, before implementing a modular exponentiation algorithm, one would implement a modular reduction algorithm. By building outward from a base foundation instead of using a parallel design methodology, you end up with a project that is highly modular. Being highly modular is a desirable property of any project as it often means the resulting product has a small footprint and updates are easy to perform. Usually, when I start a project I will begin with the header files. I define the data types I think I will need and prototype the initial functions that are not dependent on other functions (within the library). After I implement these base functions, I prototype more dependent functions and implement them. The process repeats until I implement all the functions I require. For example, in the case of LibTomMath, I implemented functions such as mp init() well before 13
14
www.syngress.com
I implemented mp mul(), and even further before I implemented mp exptmod(). As an example as to why this design works, note that the Karatsuba and ToomCook multipliers were written after the dependent function mp exptmod() was written. Adding the new multiplication algorithms did not require changes to the mp exptmod() function itself and lowered the total cost of ownership and development (so to speak ) for new algorithms. This methodology allows new algorithms to be tested in a complete framework with relative ease (Figure 2.1).
Figure 2.1: Design Flow of the First Few Original LibTomMath Functions.
Only after the majority of the functions were in place did I pursue a less hierarchical approach to auditing and optimizing the source code. For example, one day I may audit the multipliers and the next day the polynomial basis functions. It only makes sense to begin the text with the preliminary data types and support algorithms required. This chapter discusses the core algorithms of the library that are the dependents for every other algorithm.
2.2
What Is a Multiple Precision Integer?
Recall that most programming languages, in particular ISO C [17], only have fixed precision data types that on their own cannot be used to represent values larger
2.2 What Is a Multiple Precision Integer?
15
than their precision will allow. The purpose of multiple precision algorithms is to use fixed precision data types to create and manipulate multiple precision integers that may represent values that are very large. In the decimal system, the largest single digit value is 9. However, by concatenating digits together, larger numbers may be represented. Newly prepended digits (to the left ) are said to be in a different power of ten column. That is, the number 123 can be described as having a 1 in the hundreds column, 2 in the tens column, and 3 in the ones column. Or more formally, 123 = 1·102 + 2 ·101 + 3 ·100. Computer–based multiple precision arithmetic is essentially the same concept. Larger integers are represented by adjoining fixed precision computer words with the exception that a different radix is used. What most people probably do not think about explicitly are the various other attributes that describe a multiple precision integer. For example, the integer 15410 has two immediately obvious properties. First, the integer is positive; that is, the sign of this particular integer is positive as opposed to negative. Second, the integer has three digits in its representation. There is an additional property that the integer possesses that does not concern pencil-and-paper arithmetic. The third property is how many digit placeholders are available to hold the integer. A visual example of this third property is ensuring there is enough space on the paper to write the integer. For example, if one starts writing a large number too far to the right on a piece of paper, he will have to erase it and move left. Similarly, computer algorithms must maintain strict control over memory usage to ensure that the digits of an integer will not exceed the allowed boundaries. These three properties make up what is known as a multiple precision integer, or mp int for short.
2.2.1
The mp int Structure
The mp int structure is the ISO C–based manifestation of what represents a multiple precision integer. The ISO C standard does not provide for any such data type, but it does provide for making composite data types known as structures. The following is the structure definition used within LibTomMath.
16
www.syngress.com typedef struct { int used, alloc, sign; mp digit *dp; } mp int;
Figure 2.2: The mp int Structure The mp int structure (Figure 2.2) can be broken down as follows. • The used parameter denotes how many digits of the array dp contain the digits used to represent a given integer. The used count must be positive (or zero) and may not exceed the alloc count. • The alloc parameter denotes how many digits are available in the array to use by functions before it has to increase in size. When the used count of a result exceeds the alloc count, all the algorithms will automatically increase the size of the array to accommodate the precision of the result. • The pointer dp points to a dynamically allocated array of digits that represent the given multiple precision integer. It is padded with (alloc − used) zero digits. The array is maintained in a least significant digit order. As a pencil and paper analogy the array is organized such that the rightmost digits are stored first starting at the location indexed by zero1 in the array. For example, if dp contains {a, b, c, . . .} where dp0 = a, dp1 = b, dp2 = c, . . . then it would represent the integer a + bβ + cβ 2 + . . . • The sign parameter denotes the sign as either zero/positive (MP ZPOS) or negative (MP NEG). Valid mp int Structures Several rules are placed on the state of an mp int structure and are assumed to be followed for reasons of efficiency. The only exceptions are when the structure is passed to initialization functions such as mp init() and mp init copy(). 1. The value of alloc may not be less than one. That is, dp always points to a previously allocated array of digits. 1 In
C, all arrays begin at the zero index.
17
2.3 Argument Passing
2. The value of used may not exceed alloc and must be greater than or equal to zero. 3. The value of used implies the digit at index (used − 1) of the dp array is non-zero. That is, leading zero digits in the most significant positions must be trimmed. (a) Digits in the dp array at and above the used location must be zero. 4. The value of sign must be MP ZPOS if used is zero; this represents the mp int value of zero.
2.3
Argument Passing
A convention of argument passing must be adopted early in the development of any library. Making the function prototypes consistent will help eliminate many headaches in the future as the library grows to significant complexity. In LibTomMath, the multiple precision integer functions accept parameters from left to right as pointers to mp int structures. That means that the source (input) operands are placed on the left and the destination (output) on the right. Consider the following examples. mp_mul(&a, &b, &c); mp_add(&a, &b, &a); mp_sqr(&a, &b);
/* c = a * b */ /* a = a + b */ /* b = a * a */
The left to right order is a fairly natural way to implement the functions since it lets the developer read aloud the functions and make sense of them. For example, the first function would read “multiply a and b and store in c.” Certain libraries (LIP by Lenstra for instance ) accept parameters the other way around, to mimic the order of assignment expressions. That is, the destination (output) is on the left and arguments (inputs) are on the right. In truth, it is entirely a matter of preference. In the case of LibTomMath the convention from the MPI library has been adopted. Another very useful design consideration, provided for in LibTomMath, is whether to allow argument sources to also be a destination. For example, the second example (mp add ) adds a to b and stores in a. This is an important feature to implement since it allows the calling functions to cut down on the number of
18
www.syngress.com
variables it must maintain. However, to implement this feature, specific care has to be given to ensure the destination is not modified before the source is fully read.
2.4
Return Values
A well–implemented application, no matter what its purpose, should trap as many runtime errors as possible and return them to the caller. By catching runtime errors a library can be guaranteed to prevent undefined behavior. However, the end developer can still manage to cause a library to crash. For example, by passing an invalid pointer an application may fault by dereferencing memory not owned by the application. In the case of LibTomMath the only errors that are checked for are related to inappropriate inputs (division by zero for instance) and memory allocation errors. It will not check that the mp int passed to any function is valid, nor will it check pointers for validity. Any function that can cause a runtime error will return an error code as an int data type with one of the values in Figure 2.3. Value MP OKAY MP VAL MP MEM
Meaning The function was successful One of the input value(s) was invalid The function ran out of heap memory
Figure 2.3: LibTomMath Error Codes When an error is detected within a function, it should free any memory it allocated, often during the initialization of temporary mp ints, and return as soon as possible. The goal is to leave the system in the same state it was when the function was called. Error checking with this style of API is fairly simple. int err; if ((err = mp_add(&a, &b, &c)) != MP_OKAY) { printf("Error: %s\n", mp_error_to_string(err)); exit(EXIT_FAILURE); } The GMP [13] library uses C style signals to flag errors, which is of questionable use. Not all errors are fatal and it was not deemed ideal by the author of
2.5 Initialization and Clearing
19
LibTomMath to force developers to have signal handlers for such cases.
2.5
Initialization and Clearing
The logical starting point when actually writing multiple precision integer functions is the initialization and clearing of the mp int structures. These two algorithms will be used by the majority of the higher level algorithms. Given the basic mp int structure, an initialization routine must first allocate memory to hold the digits of the integer. Often it is optimal to allocate a sufficiently large pre-set number of digits even though the initial integer will represent zero. If only a single digit were allocated, quite a few subsequent reallocations would occur when operations are performed on the integers. There is a trade– off between how many default digits to allocate and how many reallocations are tolerable. Obviously, allocating an excessive amount of digits initially will waste memory and become unmanageable. If the memory for the digits has been successfully allocated, the rest of the members of the structure must be initialized. Since the initial state of an mp int is to represent the zero integer, the allocated digits must be set to zero, the used count set to zero, and sign set to MP ZPOS.
2.5.1
Initializing an mp int
An mp int is said to be initialized if it is set to a valid, preferably default, state such that all the members of the structure are set to valid values. The mp init algorithm will perform such an action (Figure 2.4).
20
www.syngress.com Algorithm mp init. Input. An mp int a Output. Allocate memory and initialize a to a known valid mp int state. 1. Allocate memory for MP PREC digits. 2. If the allocation failed, return(MP MEM ) 3. for n from 0 to M P P REC − 1 do 3.1 an ← 0 4. a.sign ← M P ZP OS 5. a.used ← 0 6. a.alloc ← M P P REC 7. Return(MP OKAY ) Figure 2.4: Algorithm mp init
Algorithm mp init. The purpose of this function is to initialize an mp int structure so that the rest of the library can properly manipulate it. It is assumed that the input may not have had any of its members previously initialized, which is certainly a valid assumption if the input resides on the stack. Before any of the members such as sign, used, or alloc are initialized, the memory for the digits is allocated. If this fails, the function returns before setting any of the other members. The MP PREC name represents a constant2 used to dictate the minimum precision of newly initialized mp int integers. Ideally, it is at least equal to the smallest precision number you’ll be working with. Allocating a block of digits at first instead of a single digit has the benefit of lowering the number of usually slow heap operations later functions will have to perform in the future. If MP PREC is set correctly, the slack memory and the number of heap operations will be trivial. Once the allocation has been made, the digits have to be set to zero, and the used, sign, and alloc members initialized. This ensures that the mp int will always represent the default state of zero regardless of the original condition of the input. Remark. This function introduces the idiosyncrasy that all iterative loops, commonly initiated with the “for” keyword, iterate incrementally when the “to” keyword is placed between two expressions. For example, “for a from b to c do” means that a subsequent expression (or body of expressions) is to be evaluated 2 Defined
in the “tommath.h” header file within LibTomMath.
2.5 Initialization and Clearing
21
up to c − b times so long as b ≤ c. In each iteration, the variable a is substituted for a new integer that lies inclusively between b and c. If b > c occurred, the loop would not iterate. By contrast, if the “downto” keyword were used in place of “to,” the loop would iterate decrementally. File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042
bn mp init.c /* init a new mp_int */ int mp_init (mp_int * a) { int i; /* allocate memory required and clear it */ a->dp = OPT_CAST(mp_digit) XMALLOC (sizeof (mp_digit) * MP_PREC); if (a->dp == NULL) { return MP_MEM; } /* set the digits to zero */ for (i = 0; i < MP_PREC; i++) { a->dp[i] = 0; } /* set the used to zero, allocated digits to the default precision * and sign to positive */ a->used = 0; a->alloc = MP_PREC; a->sign = MP_ZPOS; return MP_OKAY; }
One immediate observation of this initialization function is that it does not return a pointer to a mp int structure. It is assumed that the caller has already allocated memory for the mp int structure, typically on the application stack. The call to mp init() is used only to initialize the members of the structure to a known default state. Here we see (line 24) the memory allocation is performed first. This allows us to exit cleanly and quickly if there is an error. If the allocation fails, the routine will return MP MEM to the caller to indicate there was a memory error. The function XMALLOC is what actually allocates the memory. Technically,
22
www.syngress.com
XMALLOC is not a function but a macro defined in tommath.h. By default, XMALLOC will evaluate to malloc(), which is the C library’s built–in memory allocation routine. To assure the mp int is in a known state, the digits must be set to zero. On most platforms this could have been accomplished by using calloc() instead of malloc(). However, to correctly initialize an integer type to a given value in a portable fashion, you have to actually assign the value. The for loop (line 30) performs this required operation. After the memory has been successfully initialized, the remainder of the members are initialized (lines 34 through 35) to their respective default states. At this point, the algorithm has succeeded and a success code is returned to the calling function. If this function returns MP OKAY, it is safe to assume the mp int structure has been properly initialized and is safe to use with other functions within the library.
2.5.2
Clearing an mp int
When an mp int is no longer required by the application, the memory allocated for its digits must be returned to the application’s memory pool with the mp clear algorithm (Figure 2.5). Algorithm mp clear. Input. An mp int a Output. The memory for a shall be deallocated. 1. If a has been previously freed, then return(MP OKAY ). 2. for n from 0 to a.used − 1 do 2.1 an ← 0 3. Free the memory allocated for the digits of a. 4. a.used ← 0 5. a.alloc ← 0 6. a.sign ← M P ZP OS 7. Return(MP OKAY ). Figure 2.5: Algorithm mp clear Algorithm mp clear. This algorithm accomplishes two goals. First, it clears the digits and the other mp int members. This ensures that if a developer acci-
2.5 Initialization and Clearing
23
dentally re-uses a cleared structure it is less likely to cause problems. The second goal is to free the allocated memory. The logic behind the algorithm is extended by marking cleared mp int structures so that subsequent calls to this algorithm will not try to free the memory multiple times. Cleared mp ints are detectable by having a pre-defined invalid digit pointer dp setting. Once an mp int has been cleared, the mp int structure is no longer in a valid state for any other algorithm with the exception of algorithms mp init, mp init copy, mp init size, and mp clear. File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040
bn mp clear.c /* clear one (frees) */ void mp_clear (mp_int * a) { int i; /* only do anything if a hasn’t been freed previously */ if (a->dp != NULL) { /* first zero the digits */ for (i = 0; i < a->used; i++) { a->dp[i] = 0; } /* free ram */ XFREE(a->dp); /* reset a->dp a->alloc a->sign
members to make debugging easier */ = NULL; = a->used = 0; = MP_ZPOS;
} }
The algorithm only operates on the mp int if it hasn’t been previously cleared. The if statement (line 25) checks to see if the dp member is not NULL. If the mp int is a valid mp int, then dp cannot be NULL, in which case the if statement will evaluate to true. The digits of the mp int are cleared by the for loop (line 27), which assigns a
24
www.syngress.com
zero to every digit. Similar to mp init(), the digits are assigned zero instead of using block memory operations (such as memset()) since this is more portable. The digits are deallocated off the heap via the XFREE macro. Similar to XMALLOC, the XFREE macro actually evaluates to a standard C library function; in this case, free(). Since free() only deallocates the memory, the pointer still has to be reset to NULL manually (line 35). Now that the digits have been cleared and deallocated, the other members are set to their final values (lines 36 and 37).
2.6
Maintenance Algorithms
The previous sections described how to initialize and clear an mp int structure. To further support operations that are to be performed on mp int structures (such as addition and multiplication), the dependent algorithms must be able to augment the precision of an mp int and initialize mp ints with differing initial conditions. These algorithms complete the set of low–level algorithms required to work with mp int structures in the higher level algorithms such as addition, multiplication, and modular exponentiation.
2.6.1
Augmenting an mp int’s Precision
When you are storing a value in an mp int structure, a sufficient number of digits must be available to accommodate the entire result of an operation without loss of precision. Quite often, the size of the array given by the alloc member is large enough to simply increase the used digit count. However, when the size of the array is too small it must be re-sized appropriately to accommodate the result. The mp grow algorithm provides this functionality (Figure 2.6).
2.6 Maintenance Algorithms
25
Algorithm mp grow. Input. An mp int a and an integer b. Output. a is expanded to accommodate b digits. 1. 2. 3. 4. 5. 6.
if a.alloc ≥ b, then return(MP OKAY ) u ← b (mod M P P REC) v ← b + 2 · M P P REC − u Reallocate the array of digits a to size v If the allocation failed, then return(MP MEM ). for n from a.alloc to v − 1 do 6.1 an ← 0 7. a.alloc ← v 8. Return(MP OKAY ) Figure 2.6: Algorithm mp grow Algorithm mp grow. It is ideal to prevent reallocations from being performed if they are not required (step one). This is useful to prevent mp ints from growing excessively in code that erroneously calls mp grow. The requested digit count is padded up to the next multiple of MP PREC plus an additional MP PREC (steps two and three). This helps prevent many trivial reallocations that would grow an mp int by trivially small values. It is assumed that the reallocation (step four) leaves the lower a.alloc digits of the mp int intact. This is much akin to how the realloc function from the standard C library works. Since the newly allocated digits are assumed to contain undefined values, they are initially set to zero. File: 018 019 020 021 022 023 024 025 026 027 028
bn mp grow.c /* grow as required */ int mp_grow (mp_int * a, int size) { int i; mp_digit *tmp; /* if the alloc size is smaller alloc more ram */ if (a->alloc < size) { /* ensure there are always at least MP_PREC digits extra on top */ size += (MP_PREC * 2) - (size % MP_PREC);
26 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053
www.syngress.com /* reallocate the array a->dp * * We store the return in a temporary variable * in case the operation failed we don’t want * to overwrite the dp member of a. */ tmp = OPT_CAST(mp_digit) XREALLOC (a->dp, sizeof (mp_digit) * size); if (tmp == NULL) { /* reallocation failed but "a" is still valid [can be freed] */ return MP_MEM; } /* reallocation succeeded so set a->dp */ a->dp = tmp; /* zero excess digits */ i = a->alloc; a->alloc = size; for (; i < a->alloc; i++) { a->dp[i] = 0; } } return MP_OKAY; }
A quick optimization is to first determine if a memory reallocation is required at all. The if statement (line 24) checks if the alloc member of the mp int is smaller than the requested digit count. If the count is not larger than alloc the function skips the reallocation part, thus saving time. When a reallocation is performed, it is turned into an optimal request to save time in the future. The requested digit count is padded upwards to 2nd multiple of MP PREC larger than alloc (line 25). The XREALLOC function is used to reallocate the memory. As per the other functions, XREALLOC is actually a macro that evaluates to realloc by default. The realloc function leaves the base of the allocation intact, which means the first alloc digits of the mp int are the same as before the reallocation. All that is left is to clear the newly allocated digits and return. Note that the reallocation result is actually stored in a temporary pointer tmp. This is to allow this function to return an error with a valid pointer. Earlier
2.6 Maintenance Algorithms
27
releases of the library stored the result of XREALLOC into the mp int a. That would result in a memory leak if XREALLOC ever failed.
2.6.2
Initializing Variable Precision mp ints
Occasionally, the number of digits required will be known in advance of an initialization, based on, for example, the size of input mp ints to a given algorithm. The purpose of algorithm mp init size is similar to mp init except that it will allocate at least a specified number of digits (Function 2.7). Algorithm mp init size. Input. An mp int a and the requested number of digits b. Output. a is initialized to hold at least b digits. 1. 2. 3. 4.
u ← b (mod M P P REC) v ← b + 2 · M P P REC − u Allocate v digits. for n from 0 to v − 1 do 4.1 an ← 0 5. a.sign ← M P ZP OS 6. a.used ← 0 7. a.alloc ← v 8. Return(MP OKAY )
Figure 2.7: Algorithm mp init size Algorithm mp init size. This algorithm will initialize an mp int structure a like algorithm mp init, with the exception that the number of digits allocated can be controlled by the second input argument b. The input size is padded upwards so it is a multiple of MP PREC plus an additional MP PREC digits. This padding is used to prevent trivial allocations from becoming a bottleneck in the rest of the algorithms (Figure 2.7). Like algorithm mp init, the mp int structure is initialized to a default state representing the integer zero. This particular algorithm is useful if it is known ahead of time the approximate size of the input. If the approximation is correct, no further memory reallocations are required to work with the mp int. File: bn mp init size.c 018 /* init an mp_init for a given size */
28 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044
www.syngress.com int mp_init_size (mp_int * a, int size) { int x; /* pad size so there are always extra digits */ size += (MP_PREC * 2) - (size % MP_PREC); /* alloc mem */ a->dp = OPT_CAST(mp_digit) XMALLOC (sizeof (mp_digit) * size); if (a->dp == NULL) { return MP_MEM; } /* set the a->used = a->alloc = a->sign =
members */ 0; size; MP_ZPOS;
/* zero the digits */ for (x = 0; x < size; x++) { a->dp[x] = 0; } return MP_OKAY; }
The number of digits b requested is padded (line 24) by first augmenting it to the next multiple of MP PREC and then adding MP PREC to the result. If the memory can be successfully allocated, the mp int is placed in a default state representing the integer zero. Otherwise, the error code MP MEM will be returned (line 29). The digits are allocated and set to zero at the same time with the calloc() function (line 27). The used count is set to zero, the alloc count is set to the padded digit count and the sign flag is set to MP ZPOS to achieve a default valid mp int state (lines 33, 34, and 35). If the function returns successfully, then it is correct to assume that the mp int structure is in a valid state for the remainder of the functions to work with.
2.6 Maintenance Algorithms
2.6.3
29
Multiple Integer Initializations and Clearings
Occasionally, a function will require a series of mp int data types to be made available simultaneously. The purpose of algorithm mp init multi (Figure 2.8) is to initialize a variable length array of mp int structures in a single statement. It is essentially a shortcut to multiple initializations. Algorithm mp init multi. Input. Variable length array Vk of mp int variables of length k. Output. The array is initialized such that each mp int of Vk is ready to use. 1. for n from 0 to k − 1 do 1.1. Initialize the mp int Vn (mp init ) 1.2. If initialization failed then do 1.2.1. for j from 0 to n do 1.2.1.1. Free the mp int Vj (mp clear ) 1.2.2. Return(MP MEM ) 2. Return(MP OKAY ) Figure 2.8: Algorithm mp init multi Algorithm mp init multi. The algorithm will initialize the array of mp int variables one at a time. If a runtime error has been detected (step 1.2 ), all of the previously initialized variables are cleared. The goal is an “all or nothing” initialization, which allows for quick recovery from runtime errors (Figure 2.8). File: 017 018 019 020 021 022 023 024 025 026 027 028
bn mp init multi.c #include <stdarg.h> int mp_init_multi(mp_int *mp, ...) { mp_err res = MP_OKAY; /* Assume ok until proven otherwise */ int n = 0; /* Number of ok inits */ mp_int* cur_arg = mp; va_list args; va_start(args, mp); /* init args to next argument from caller */ while (cur_arg != NULL) { if (mp_init(cur_arg) != MP_OKAY) {
30 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055
www.syngress.com /* Oops - error! Back-track and mp_clear what we already succeeded in init-ing, then return error. */ va_list clean_args; /* end the current list */ va_end(args); /* now start cleaning up */ cur_arg = mp; va_start(clean_args, mp); while (n--) { mp_clear(cur_arg); cur_arg = va_arg(clean_args, mp_int*); } va_end(clean_args); res = MP_MEM; break; } n++; cur_arg = va_arg(args, mp_int*); } va_end(args); return res;
/* Assumed ok, if error flagged above. */
}
This function initializes a variable length list of mp int structure pointers. However, instead of having the mp int structures in an actual C array, they are simply passed as arguments to the function. This function makes use of the “...” argument syntax of the C programming language. The list is terminated with a final NULL argument appended on the right. The function uses the “stdarg.h” va functions to step in a portable fashion through the arguments to the function. A count n of successfully initialized mp int structures is maintained (line 48) such that if a failure does occur, the algorithm can backtrack and free the previously initialized structures (lines 28 to 47).
2.6 Maintenance Algorithms
2.6.4
31
Clamping Excess Digits
When a function anticipates a result will be n digits, it is simpler to assume this is true within the body of the function instead of checking during the computation. For example, a multiplication of a i digit number by a j digit produces a result of at most i + j digits. It is entirely possible that the result is i + j − 1, though, with no final carry into the last position. However, suppose the destination had to be first expanded (via mp grow ) to accommodate i + j − 1 digits than further expanded to accommodate the final carry. That would be a considerable waste of time since heap operations are relatively slow. The ideal solution is to always assume the result is i + j and fix up the used count after the function terminates. This way, a single heap operation (at most ) is required. However, if the result was not checked there would be an excess high order zero digit. For example, suppose the product of two integers was xn = (0xn−1 xn−2 ...x0 )β . The leading zero digit will not contribute to the precision of the result. In fact, through subsequent operations more leading zero digits would accumulate to the point the size of the integer would be prohibitive. As a result, even though the precision is very low the representation is excessively large. The mp clamp algorithm is designed to solve this very problem. It will trim high-order zeros by decrementing the used count until a non-zero most significant digit is found. Also in this system, zero is considered a positive number, which means that if the used count is decremented to zero, the sign must be set to MP ZPOS. Algorithm mp clamp. Input. An mp int a Output. Any excess leading zero digits of a are removed 1. while a.used > 0 and aa.used−1 = 0 do 1.1 a.used ← a.used − 1 2. if a.used = 0 then do 2.1 a.sign ← M P ZP OS
Figure 2.9: Algorithm mp clamp Algorithm mp clamp. As can be expected, this algorithm is very simple.
32
www.syngress.com
The loop in step one is expected to iterate only once or twice at the most. For example, this will happen in cases where there is not a carry to fill the last position. Step two fixes the sign for when all of the digits are zero to ensure that the mp int is valid at all times (Figure 2.9). File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040
bn mp clamp.c /* trim unused digits * * This is used to ensure that leading zero digits are * trimed and the leading "used" digit will be non-zero * Typically very fast. Also fixes the sign if there * are no more leading digits */ void mp_clamp (mp_int * a) { /* decrease used while the most significant digit is * zero. */ while (a->used > 0 && a->dp[a->used - 1] == 0) { --(a->used); } /* reset the sign flag if used == 0 */ if (a->used == 0) { a->sign = MP_ZPOS; } }
Note on line 31 how to test for the used count is made on the left of the && operator. In the C programming language, the terms to && are evaluated left to right with a boolean short-circuit if any condition fails. This is important since if the used is zero, the test on the right would fetch below the array. That is obviously undesirable. The parenthesis on line 32 is used to make sure the used count is decremented and not the pointer “a”.
Exercises
33
Exercises [1]
Discuss the relevance of the used member of the mp int structure.
[1]
Discuss the consequences of not using padding when performing allocations.
[2]
Estimate an ideal value for MP PREC when performing 1024-bit RSA encryption when β = 228 .
[1]
Discuss the relevance of the algorithm mp clamp. What does it prevent?
[1]
Give an example of when the algorithm mp init copy might be useful.
Chapter 3
Basic Operations 3.1
Introduction
In the previous chapter, a series of low–level algorithms was established that dealt with initializing and maintaining mp int structures. This chapter will discuss another set of seemingly non-algebraic algorithms that will form the low–level basis of the entire library. While these algorithms are relatively trivial, it is important to understand how they work before proceeding since these algorithms will be used almost intrinsically in the following chapters. The algorithms in this chapter deal primarily with more “programmer” related tasks such as creating copies of mp int structures, assigning small values to mp int structures and comparisons of the values mp int structures represent.
3.2 3.2.1
Assigning Values to mp int Structures Copying an mp int
Assigning the value that a given mp int structure represents to another mp int structure shall be known as making a copy for the purposes of this text. The copy of the mp int will be a separate entity that represents the same value as the mp int it was copied from. The mp copy algorithm provides this functionality (Figure 3.1).
35
36
www.syngress.com Algorithm mp copy. Input. An mp int a and b. Output. Store a copy of a in b. 1. If b.alloc < a.used then grow b to a.used digits. (mp grow ) 2. for n from 0 to a.used − 1 do 2.1 bn ← an 3. for n from a.used to b.used − 1 do 3.1 bn ← 0 4. b.used ← a.used 5. b.sign ← a.sign 6. return(MP OKAY ) Figure 3.1: Algorithm mp copy
Algorithm mp copy. This algorithm copies the mp int a such that upon successful termination of the algorithm, the mp int b will represent the same integer as the mp int a. The mp int b shall be a complete and distinct copy of the mp int a, meaning that the mp int a can be modified and it shall not affect the value of the mp int b. If b does not have enough room for the digits of a, it must first have its precision augmented via the mp grow algorithm. The digits of a are copied over the digits of b, and any excess digits of b are set to zero (steps two and three). The used and sign members of a are finally copied over the respective members of b. Remark. This algorithm also introduces a new idiosyncrasy that will be used throughout the rest of the text. The error return codes of other algorithms are not explicitly checked in the pseudo-code presented. For example, in step one of the mp copy algorithm, the return of mp grow is not explicitly checked to ensure it succeeded. Text space is limited so it is assumed that if an algorithm fails it will clear all temporarily allocated mp ints and return the error code itself. However, the C code presented will demonstrate all of the error handling logic required to implement the pseudo-code. File: 018 019 020 021
bn mp copy.c /* copy, b = a */ int mp_copy (mp_int * a, mp_int * b) {
3.2 Assigning Values to mp int Structures 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062
int
res, n;
/* if dst == src do nothing */ if (a == b) { return MP_OKAY; } /* grow dest */ if (b->alloc < a->used) { if ((res = mp_grow (b, a->used)) != MP_OKAY) { return res; } } /* zero b and copy the parameters over */ { register mp_digit *tmpa, *tmpb; /* pointer aliases */ /* source */ tmpa = a->dp; /* destination */ tmpb = b->dp; /* copy all the digits */ for (n = 0; n < a->used; n++) { *tmpb++ = *tmpa++; } /* clear high digits */ for (; n < b->used; n++) { *tmpb++ = 0; } } /* copy used count and sign */ b->used = a->used; b->sign = a->sign; return MP_OKAY;
37
38 063 064
www.syngress.com }
Occasionally, a dependent algorithm may copy an mp int effectively into itself such as when the input and output mp int structures passed to a function are one and the same. For this case, it is optimal to return immediately without copying digits (line 25). The mp int b must have enough digits to accommodate the used digits of the mp int a. If b.alloc is less than a.used, the algorithm mp grow is used to augment the precision of b (lines 30 to 33). To simplify the inner loop that copies the digits from a to b, two aliases tmpa and tmpb point directly at the digits of the mp ints a and b, respectively. These aliases (lines 43 and 46) allow the compiler to access the digits without first dereferencing the mp int pointers and then subsequently the pointer to the digits. After the aliases are established, the digits from a are copied into b (lines 49 to 51) and then the excess digits of b are set to zero (lines 54 to 56). Both “for” loops make use of the pointer aliases, and in fact the alias for b is carried through into the second “for” loop to clear the excess digits. This optimization allows the alias to stay in a machine register fairly easy between the two loops. Remarks. The use of pointer aliases is an implementation methodology first introduced in this function that will be used considerably in other functions. Technically, a pointer alias is simply a shorthand alias used to lower the number of pointer dereferencing operations required to access data. For example, a for loop may resemble for (x = 0; x < 100; x++) { a->num[4]->dp[x] = 0; } This could be re-written using aliases as mp_digit *tmpa; a = a->num[4]->dp; for (x = 0; x < 100; x++) { *a++ = 0; } In this case, an alias is used to access the array of digits within an mp int structure directly. It may seem that a pointer alias is strictly not required, as a
3.2 Assigning Values to mp int Structures
39
compiler may optimize out the redundant pointer operations. However, there are two dominant reasons to use aliases. The first reason is that most compilers will not effectively optimize pointer arithmetic. For example, some optimizations may work for the Microsoft Visual C++ compiler (MSVC) and not for the GNU C Compiler (GCC). Moreover, some optimizations may work for GCC and not MSVC. As such it is ideal to find a common ground for as many compilers as possible. Pointer aliases optimize the code considerably before the compiler even reads the source code, which means the end compiled code stands a better chance of being faster. The second reason is that pointer aliases often can make an algorithm simpler to read. Consider the first “for” loop of the function mp copy() re-written to not use pointer aliases. /* copy all the digits */ for (n = 0; n < a->used; n++) { b->dp[n] = a->dp[n]; } Whether this code is harder to read depends strongly on the individual. However, it is quantifiably slightly more complicated, as there are four variables within the statement instead of just two. Nested Statements Another commonly used technique in the source routines is that certain sections of code are nested. This is used in particular with the pointer aliases to highlight code phases. For example, a Comba multiplier (discussed in Chapter 6) will typically have three different phases. First, the temporaries are initialized, then the columns calculated, and finally the carries are propagated. In this example, the middle column production phase will typically be nested as it uses temporary variables and aliases the most. The nesting also simplifies the source code, as variables that are nested are only valid for their scope. As a result, the various temporary variables required do not propagate into other sections of code.
3.2.2
Creating a Clone
Another common operation is to make a local temporary copy of an mp int argument. To initialize an mp int and then copy another existing mp int into the
40
www.syngress.com
newly initialized mp int will be known as creating a clone. This is useful within functions that need to modify an argument but do not wish to modify the original copy. The mp init copy algorithm has been designed to help perform this task (Figure 3.2). Algorithm mp init copy. Input. An mp int a and b Output. a is initialized to be a copy of b. 1. Init a. (mp init ) 2. Copy b to a. (mp copy) 3. Return the status of the copy operation. Figure 3.2: Algorithm mp init copy Algorithm mp init copy. This algorithm will initialize an mp int variable and copy another previously initialized mp int variable into it. As such, this algorithm will perform two operations in one step. File: 018 019 020 021 022 023 024 025 026 027 028
bn mp init copy.c /* creates "a" then copies b into it */ int mp_init_copy (mp_int * a, mp_int * b) { int res; if ((res = mp_init (a)) != MP_OKAY) { return res; } return mp_copy (b, a); }
This will initialize a and make it a verbatim copy of the contents of b. Note that a will have its own memory allocated, which means that b may be cleared after the call and a will be left intact.
41
3.3 Zeroing an Integer
3.3
Zeroing an Integer
Resetting an mp int to the default state is a common step in many algorithms. The mp zero algorithm will be used to perform this task (Figure 3.3). Algorithm mp zero. Input. An mp int a Output. Zero the contents of a 1. a.used ← 0 2. a.sign ← MP ZPOS 3. for n from 0 to a.alloc − 1 do 3.1 an ← 0 Figure 3.3: Algorithm mp zero Algorithm mp zero. This algorithm simply resets a mp int to the default state. File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032
bn mp zero.c /* set to zero */ void mp_zero (mp_int * a) { int n; mp_digit *tmp; a->sign = MP_ZPOS; a->used = 0; tmp = a->dp; for (n = 0; n < a->alloc; n++) { *tmp++ = 0; } }
After the function is completed, all of the digits are zeroed, the used count is zeroed, and the sign variable is set to MP ZPOS.
42
3.4 3.4.1
www.syngress.com
Sign Manipulation Absolute Value
With the mp int representation of an integer, calculating the absolute value is trivial. The mp abs algorithm will compute the absolute value of an mp int (Figure 3.4). Algorithm mp abs. Input. An mp int a Output. Computes b = |a| 1. 2. 3. 4.
Copy a to b. (mp copy) If the copy failed return(MP MEM ). b.sign ← M P ZP OS Return(MP OKAY ) Figure 3.4: Algorithm mp abs
Algorithm mp abs. This algorithm computes the absolute of an mp int input. First, it copies a over b. This is an example of an algorithm where the check in mp copy that determines if the source and destination are equal proves useful. This allows, for instance, the developer to pass the same mp int as the source and destination to this function without additional logic to handle it. File: 018 019 020 021 022 023 024 025 026 027 028 029 030
bn mp abs.c /* b = |a| * * Simple function copies the input and fixes the sign to positive */ int mp_abs (mp_int * a, mp_int * b) { int res; /* copy a to b */ if (a != b) { if ((res = mp_copy (a, b)) != MP_OKAY) { return res;
43
3.4 Sign Manipulation 031 032 033 034 035 036 037 038 039
} } /* force the sign of b to positive */ b->sign = MP_ZPOS; return MP_OKAY; }
This fairly trivial algorithm first eliminates non–required duplications (line 28) and then sets the sign flag to MP ZPOS.
3.4.2
Integer Negation
With the mp int representation of an integer, calculating the negation is also trivial. The mp neg algorithm will compute the negative of an mp int input (Figure 3.5). Algorithm mp neg. Input. An mp int a Output. Computes b = −a 1. 2. 3. 4.
Copy a to b. (mp copy) If the copy failed return(MP MEM ). If a.used = 0 then return(MP OKAY ). If a.sign = M P ZP OS then do 4.1 b.sign = M P N EG. 5. else do 5.1 b.sign = M P ZP OS. 6. Return(MP OKAY ) Figure 3.5: Algorithm mp neg Algorithm mp neg. This algorithm computes the negation of an input. First, it copies a over b. If a has no used digits, then the algorithm returns immediately. Otherwise, it flips the sign flag and stores the result in b. Note that if a had no digits, then it must be positive by definition. Had step three been omitted, the algorithm would return zero as negative.
44 File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036
www.syngress.com bn mp neg.c /* b = -a */ int mp_neg (mp_int * a, mp_int * b) { int res; if (a != b) { if ((res = mp_copy (a, b)) != MP_OKAY) { return res; } } if (mp_iszero(b) != MP_YES) { b->sign = (a->sign == MP_ZPOS) ? MP_NEG : MP_ZPOS; } else { b->sign = MP_ZPOS; } return MP_OKAY; }
Like mp abs(), this function avoids non–required duplications (line 22) and then sets the sign. We have to make sure that only non–zero values get a sign of MP NEG. If the mp int is zero, the sign is hard–coded to MP ZPOS.
3.5 3.5.1
Small Constants Setting Small Constants
Often, a mp int must be set to a relatively small value such as 1 or 2. For these cases, the mp set algorithm is useful (Figure 3.6).
45
3.5 Small Constants Algorithm mp set. Input. An mp int a and a digit b Output. Make a equivalent to b 1. Zero a (mp zero). 2. a0 ← b (mod β) 1 if a0 > 0 3. a.used ← 0 if a0 = 0 Figure 3.6: Algorithm mp set
Algorithm mp set. This algorithm sets a mp int to a small single digit value. Step number 1 ensures that the integer is reset to the default state. The single digit is set (modulo β) and the used count is adjusted accordingly. File: 018 019 020 021 022 023 024 025
bn mp set.c /* set to a digit */ void mp_set (mp_int * a, mp_digit b) { mp_zero (a); a->dp[0] = b & MP_MASK; a->used = (a->dp[0] != 0) ? 1 : 0; }
First, we zero (line 21) the mp int to make sure the other members are initialized for a small positive constant. mp zero() ensures that the sign is positive and the used count is zero. Next, we set the digit and reduce it modulo β (line 22). After this step, we have to check if the resulting digit is zero or not. If it is not, we set the used count to one, otherwise to zero. We can quickly reduce modulo β since it is of the form 2k , and a quick binary AND operation with 2k − 1 will perform the same operation. One important limitation of this function is that it will only set one digit. The size of a digit is not fixed, meaning source that uses this function should take that into account. Only trivially small constants can be set using this function.
46
3.5.2
www.syngress.com
Setting Large Constants
To overcome the limitations of the mp set algorithm, the mp set int algorithm is ideal. It accepts a “long” data type as input and will always treat it as a 32-bit integer (Figure 3.7). Algorithm mp set int. Input. An mp int a and a “long” integer b Output. Make a equivalent to b 1. Zero a (mp zero) 2. for n from 0 to 7 do 2.1 a ← a · 16 (mp mul2d ) 2.2 u ← ⌊b/24(7−n) ⌋ (mod 16) 2.3 a0 ← a0 + u 2.4 a.used ← a.used + 1 3. Clamp excess used digits (mp clamp) Figure 3.7: Algorithm mp set int Algorithm mp set int. The algorithm performs eight iterations of a simple loop where in each iteration, four bits from the source are added to the mp int. Step 2.1 will multiply the current result by sixteen, making room for four more bits in the less significant positions. In step 2.2, the next four bits from the source are extracted and are added to the mp int. The used digit count is incremented to reflect the addition. The used digit counter is incremented since if any of the leading digits were zero, the mp int would have zero digits used and the newly added four bits would be ignored. Excess zero digits are trimmed in steps 2.1 and 3 by using higher level algorithms mp mul2d and mp clamp. File: 018 019 020 021 022 023 024
bn mp set int.c /* set a 32-bit const */ int mp_set_int (mp_int * a, unsigned long b) { int x, res; mp_zero (a);
3.6 Comparisons 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044
47
/* set four bits at a time */ for (x = 0; x < 8; x++) { /* shift the number up four bits */ if ((res = mp_mul_2d (a, 4, a)) != MP_OKAY) { return res; } /* OR in the top four bits of the source */ a->dp[0] |= (b >> 28) & 15; /* shift the source up to the next four bits */ b b.used then return(MP GT ) 2. If a.used < b.used then return(MP LT ) 3. for n from a.used − 1 to 0 do 3.1 if an > bn then return(MP GT ) 3.2 if an < bn then return(MP LT ) 4. Return(MP EQ ) Figure 3.9: Algorithm mp cmp mag Algorithm mp cmp mag. By saying “a to the left of b,” it is meant that the comparison is with respect to a. That is, if a is greater than b it will return MP GT and similar with respect to when a = b and a < b. The first two steps compare the number of digits used in both a and b. Obviously, if the digit counts differ there would be an imaginary zero digit in the smaller number where the leading digit of the larger number is. If both have the same number of digits, the actual digits themselves must be compared starting at the leading digit (Figure 3.9).
3.6 Comparisons
49
By step three, both inputs must have the same number of digits so, it is safe to start from either a.used − 1 or b.used − 1 and count down to the zero’th digit. If after all of the digits have been compared and no difference is found, the algorithm returns MP EQ. File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051
bn mp cmp mag.c /* compare magnitude of two ints (unsigned) */ int mp_cmp_mag (mp_int * a, mp_int * b) { int n; mp_digit *tmpa, *tmpb; /* compare based on # of non-zero digits */ if (a->used > b->used) { return MP_GT; } if (a->used < b->used) { return MP_LT; } /* alias for a */ tmpa = a->dp + (a->used - 1); /* alias for b */ tmpb = b->dp + (a->used - 1); /* compare based on digits */ for (n = 0; n < a->used; ++n, --tmpa, --tmpb) { if (*tmpa > *tmpb) { return MP_GT; } if (*tmpa < *tmpb) { return MP_LT; } } return MP_EQ; }
The two if statements (lines 25 and 29) compare the number of digits in the
50
www.syngress.com
two inputs. These two are performed before all the digits are compared, since it is a very cheap test to perform and can potentially save considerable time. The implementation given is also not valid without those two statements. b.alloc may be smaller than a.used, meaning that undefined values will be read from b past the end of the array of digits.
3.6.2
Signed Comparisons
Comparing with sign comparisons is also fairly critical in several routines (division, for example). Based on an unsigned magnitude comparison, a trivial signed comparison algorithm can be written. Algorithm mp cmp. Input. Two mp ints a and b Output. Signed Comparison Results (a to the left of b) 1. if a.sign = M P N EG and b.sign = M P ZP OS then return(MP LT ) 2. if a.sign = M P ZP OS and b.sign = M P N EG then return(MP GT ) 3. if a.sign = M P N EG then 3.1 Return the unsigned comparison of b and a (mp cmp mag) 4 Otherwise 4.1 Return the unsigned comparison of a and b Figure 3.10: Algorithm mp cmp Algorithm mp cmp. The first two steps compare the signs of the two inputs. If the signs do not agree, then it can return right away with the appropriate comparison code. When the signs are equal, the digits of the inputs must be compared to determine the correct result. In step three, the unsigned comparison flips the order of the arguments since they are both negative. For instance, if −a > −b then |a| < |b|. Step four will compare the two when they are both positive (Figure 3.10).
3.6 Comparisons File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039
51
bn mp cmp.c /* compare two ints (signed)*/ int mp_cmp (mp_int * a, mp_int * b) { /* compare based on sign */ if (a->sign != b->sign) { if (a->sign == MP_NEG) { return MP_LT; } else { return MP_GT; } } /* compare digits */ if (a->sign == MP_NEG) { /* if negative compare opposite direction */ return mp_cmp_mag(b, a); } else { return mp_cmp_mag(a, b); } }
The two if statements (lines 23 and 24) perform the initial sign comparison. If the signs are not equal, then whichever has the positive sign is larger. The inputs are compared (line 32) based on magnitudes. If the signs were both negative, then the unsigned comparison is performed in the opposite direction (line 34). Otherwise, the signs are assumed to be positive and a forward direction unsigned comparison is performed.
52
www.syngress.com
Exercises [2]
Modify algorithm mp set int to accept as input a variable length array of bits.
[3]
Give the probability that algorithm mp cmp mag will have to compare k digits of two random digits (of equal magnitude) before a difference is found.
[1]
Suggest a simple method to speed up the implementation of mp cmp mag based on the observations made in the previous problem.
Chapter 4
Basic Arithmetic 4.1
Introduction
At this point, algorithms for initialization, clearing, zeroing, copying, comparing, and setting small constants have been established. The next logical set of algorithms to develop are addition, subtraction, and digit shifting algorithms. These algorithms make use of the lower level algorithms and are the crucial building block for the multiplication algorithms. It is very important that these algorithms are highly optimized. On their own they are simple O(n) algorithms but they can be called from higher level algorithms, which easily places them at O(n2 ) or even O(n3 ) work levels. All of the algorithms within this chapter make use of the logical bit shift operations denoted by > for left and right logical shifts, respectively. A logical shift is analogous to sliding the decimal point of radix-10 representations. For example, the real number 0.9345 is equivalent to 93.45%, which is found by sliding the decimal two places to the right (multiplying by β 2 = 102 ). Algebraically, a binary logical shift is equivalent to a division or multiplication by a power of two. For example, a > k = ⌊a/2k ⌋. One significant difference between a logical shift and the way decimals are shifted is that digits below the zero’th position are removed from the number. For example, consider 11012 >> 1; using decimal notation this would produce 110.12. However, with a logical shift the result is 1102 . 53
54
4.2
www.syngress.com
Addition and Subtraction
In common twos complement fixed precision arithmetic negative numbers are easily represented by subtraction from the modulus. For example, with 32-bit integers, a−b (mod 232 ) is the same as a+(232 −b) (mod 232 ) since 232 ≡ 0 (mod 232 ). As a result, subtraction can be performed with a trivial series of logical operations and an addition. However, in multiple precision arithmetic, negative numbers are not represented in the same way. Instead, a sign flag is used to keep track of the sign of the integer. As a result, signed addition and subtraction are actually implemented as conditional usage of lower level addition or subtraction algorithms with the sign fixed up appropriately. The lower level algorithms will add or subtract integers without regard to the sign flag. That is, they will add or subtract the magnitude of the integers, respectively.
4.2.1
Low Level Addition
An unsigned addition of multiple precision integers is performed with the same long-hand algorithm used to add decimal numbers; that is, to add the trailing digits first and propagate the resulting carry upward. Since this is a lower level algorithm, the name will have a “s ” prefix. Historically, that convention stems from the MPI library, where “s ” stood for static functions that were hidden from the developer entirely.
4.2 Addition and Subtraction
55
Algorithm s mp add. Input. Two mp ints a and b Output. The unsigned addition c = |a| + |b|. 1. if a.used > b.used then 1.1 min ← b.used 1.2 max ← a.used 1.3 x ← a 2. else 2.1 min ← a.used 2.2 max ← b.used 2.3 x ← b 3. If c.alloc < max + 1 then grow c to hold at least max + 1 digits (mp grow ) 4. oldused ← c.used 5. c.used ← max + 1 6. u ← 0 7. for n from 0 to min − 1 do 7.1 cn ← an + bn + u 7.2 u ← cn >> lg(β) 7.3 cn ← cn (mod β) 8. if min 6= max then do 8.1 for n from min to max − 1 do 8.1.1 cn ← xn + u 8.1.2 u ← cn >> lg(β) 8.1.3 cn ← cn (mod β) 9. cmax ← u 10. if olduse > max then 10.1 for n from max + 1 to oldused − 1 do 10.1.1 cn ← 0 11. Clamp excess digits in c. (mp clamp) 12. Return(MP OKAY )
Figure 4.1: Algorithm s mp add Algorithm s mp add. This algorithm is loosely based on algorithm 14.7 of HAC [2, pp. 594], but has been extended to allow the inputs to have different magnitudes. Coincidentally, the description of algorithm A in Knuth [1, pp. 266] shares the same deficiency as the algorithm from [2]. Even the MIX pseudo machine code presented by Knuth [1, pp. 266–267] is incapable of handling inputs of different magnitudes (Figure 4.1).
56
www.syngress.com
The first thing that has to be accomplished is to sort out which of the two inputs is the largest. The addition logic will simply add all of the smallest input to the largest input and store that first part of the result in the destination. Then, it will apply a simpler addition loop to excess digits of the larger input. The first two steps will handle sorting the inputs such that min and max hold the digit counts of the two inputs. The variable x will be an mp int alias for the largest input or the second input b if they have the same number of digits. After the inputs are sorted, the destination c is grown as required to accommodate the sum of the two inputs. The original used count of c is copied and set to the new used count. At this point, the first addition loop will go through as many digit positions as both inputs have. The carry variable µ is set to zero outside the loop. Inside the loop an “addition” step requires three statements to produce one digit of the summand. The first two digits from a and b are added together along with the carry µ. The carry of this step is extracted and stored in µ, and finally the digit of the result cn is truncated within the range 0 ≤ cn < β. Now all of the digit positions that both inputs have in common have been exhausted. If min 6= max, then x is an alias for one of the inputs that has more digits. A simplified addition loop is then used to essentially copy the remaining digits and the carry to the destination. The final carry is stored in cmax , and digits above max up to oldused are zeroed, which completes the addition. File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033
bn s mp add.c /* low level addition, based on HAC pp.594, Algorithm 14.7 */ int s_mp_add (mp_int * a, mp_int * b, mp_int * c) { mp_int *x; int olduse, res, min, max; /* find sizes, we let |a| used > b->used) { min = b->used; max = a->used; x = a; } else { min = a->used;
4.2 Addition and Subtraction 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074
max = b->used; x = b; } /* init result */ if (c->alloc < max + 1) { if ((res = mp_grow (c, max + 1)) != MP_OKAY) { return res; } } /* get old used digit count and set new one */ olduse = c->used; c->used = max + 1; { register mp_digit u, *tmpa, *tmpb, *tmpc; register int i; /* alias for digit pointers */ /* first input */ tmpa = a->dp; /* second input */ tmpb = b->dp; /* destination */ tmpc = c->dp; /* zero the carry */ u = 0; for (i = 0; i < min; i++) { /* Compute the sum at one digit, T[i] = A[i] + B[i] + U */ *tmpc = *tmpa++ + *tmpb++ + u; /* U = carry bit of T[i] */ u = *tmpc >> ((mp_digit)DIGIT_BIT); /* take away carry bit from T[i] */ *tmpc++ &= MP_MASK;
57
58 075 076 077 078 079 080 081 082 083 084 085 086 087 088 089 090 091 092 093 094 095 096 097 098 099 100 101 102 103 104 105
www.syngress.com } /* now copy higher words if any, that is in A+B * if A or B has more digits add those in */ if (min != max) { for (; i < max; i++) { /* T[i] = X[i] + U */ *tmpc = x->dp[i] + u; /* U = carry bit of T[i] */ u = *tmpc >> ((mp_digit)DIGIT_BIT); /* take away carry bit from T[i] */ *tmpc++ &= MP_MASK; } } /* add carry */ *tmpc++ = u; /* clear digits above oldused */ for (i = c->used; i < olduse; i++) { *tmpc++ = 0; } } mp_clamp (c); return MP_OKAY; }
We first sort (lines 28 to 36) the inputs based on magnitude and determine the min and max variables. Note that x is a pointer to an mp int assigned to the largest input, in effect it is a local alias. Next, we grow the destination (38 to 42) to ensure it can accommodate the result of the addition. Similar to the implementation of mp copy, this function uses the braced code and local aliases coding style. The three aliases on lines 56, 59 and 62 represent the two inputs and destination variables, respectively. These aliases are used to ensure the compiler does not have to dereference a, b, or c (respectively) to access the digits of the respective mp int.
4.2 Addition and Subtraction
59
The initial carry u will be cleared (line 65); note that u is of type mp digit, which ensures type compatibility within the implementation. The initial addition (lines 66 to 75) adds digits from both inputs until the smallest input runs out of digits. Similarly, the conditional addition loop (lines 81 to 90) adds the remaining digits from the larger of the two inputs. The addition is finished with the final carry being stored in tmpc (line 94). Note the “++” operator within the same expression. After line 94, tmpc will point to the c.used’th digit of the mp int c. This is useful for the next loop (lines 97 to 99), which sets any old upper digits to zero.
4.2.2
Low Level Subtraction
The low level unsigned subtraction algorithm is very similar to the low level unsigned addition algorithm. The principal difference is that the unsigned subtraction algorithm requires the result to be positive. That is, when computing a − b, the condition |a| ≥ |b| must be met for this algorithm to function properly. Keep in mind this low level algorithm is not meant to be used in higher level algorithms directly. This algorithm as will be shown can be used to create functional signed addition and subtraction algorithms. For this algorithm, a new variable is required to make the description simpler. Recall from section 1.3.1 that a mp digit must be able to represent the range 0 ≤ x < 2β for the algorithms to work correctly. However, it is allowable that a mp digit represent a larger range of values. For this algorithm, we will assume that the variable γ represents the number of bits available in a mp digit (this implies 2γ > β). For example, the default for LibTomMath is to use a “unsigned long” for the mp digit “type” while β = 228 . In ISO C, an “unsigned long” data type must be able to represent 0 ≤ x < 232 , meaning that in this case γ ≥ 32.
60
www.syngress.com Algorithm s mp sub. Input. Two mp ints a and b (|a| ≥ |b|) Output. The unsigned subtraction c = |a| − |b|. 1. 2. 3. 4. 5. 6. 7.
min ← b.used max ← a.used If c.alloc < max then grow c to hold at least max digits. (mp grow ) oldused ← c.used c.used ← max u←0 for n from 0 to min − 1 do 7.1 cn ← an − bn − u 7.2 u ← cn >> (γ − 1) 7.3 cn ← cn (mod β) 8. if min < max then do 8.1 for n from min to max − 1 do 8.1.1 cn ← an − u 8.1.2 u ← cn >> (γ − 1) 8.1.3 cn ← cn (mod β) 9. if oldused > max then do 9.1 for n from max to oldused − 1 do 9.1.1 cn ← 0 10. Clamp excess digits of c. (mp clamp). 11. Return(MP OKAY ).
Figure 4.2: Algorithm s mp sub Algorithm s mp sub. This algorithm performs the unsigned subtraction of two mp int variables under the restriction that the result must be positive. That is, when passing variables a and b the condition that |a| ≥ |b| must be met for the algorithm to function correctly. This algorithm is loosely based on algorithm 14.9 [2, pp. 595] and is similar to algorithm S in [1, pp. 267] as well. As was the case of the algorithm s mp add both other references lack discussion concerning various practical details such as when the inputs differ in magnitude (Figure 4.2). The initial sorting of the inputs is trivial in this algorithm since a is guaranteed to have at least the same magnitude of b. Steps 1 and 2 set the min and max variables. Unlike the addition routine there is guaranteed to be no carry, which means that the result can be at most max digits in length as opposed to max + 1. Similar to the addition algorithm, the used count of c is copied locally and set to
4.2 Addition and Subtraction
61
the maximal count for the operation. The subtraction loop that begins on step 7 is essentially the same as the addition loop of algorithm s mp add, except single precision subtraction is used instead. Note the use of the γ variable to extract the carry (also known as the borrow ) within the subtraction loops. Under the assumption that two’s complement single precision arithmetic is used, this will successfully extract the desired carry. For example, consider subtracting 01012 from 01002 , where γ = 4 and β = 2. The least significant bit will force a carry upwards to the third bit, which will be set to zero after the borrow. After the very first bit has been subtracted, 4 − 1 ≡ 00112 will remain, When the third bit of 01012 is subtracted from the result it will cause another carry. In this case, though, the carry will be forced to propagate all the way to the most significant bit. Recall that β < 2γ . This means that if a carry does occur just before the lg(β)’th bit it will propagate all the way to the most significant bit. Thus, the high order bits of the mp digit that are not part of the actual digit will either be all zero, or all one. All that is needed is a single zero or one bit for the carry. Therefore, a single logical shift right by γ − 1 positions is sufficient to extract the carry. This method of carry extraction may seem awkward, but the reason for it becomes apparent when the implementation is discussed. If b has a smaller magnitude than a, then step 9 will force the carry and copy operation to propagate through the larger input a into c. Step 10 will ensure that any leading digits of c above the max’th position are zeroed. File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031
bn s mp sub.c /* low level subtraction (assumes |a| > |b|), HAC pp.595 Algorithm 14.9 */ int s_mp_sub (mp_int * a, mp_int * b, mp_int * c) { int olduse, res, min, max; /* find sizes */ min = b->used; max = a->used; /* init result */ if (c->alloc < max) { if ((res = mp_grow (c, max)) != MP_OKAY) { return res;
62 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072
www.syngress.com } } olduse = c->used; c->used = max; { register mp_digit u, *tmpa, *tmpb, *tmpc; register int i; /* alias for digit pointers */ tmpa = a->dp; tmpb = b->dp; tmpc = c->dp; /* set carry to zero */ u = 0; for (i = 0; i < min; i++) { /* T[i] = A[i] - B[i] - U */ *tmpc = *tmpa++ - *tmpb++ - u; /* U = carry bit of T[i] * Note this saves performing an AND operation since * if a carry does occur it will propagate all the way to the * MSB. As a result a single shift is enough to get the carry */ u = *tmpc >> ((mp_digit)(CHAR_BIT * sizeof (mp_digit) - 1)); /* Clear carry from T[i] */ *tmpc++ &= MP_MASK; } /* now copy higher words if any, e.g. if A has more digits than B for (; i < max; i++) { /* T[i] = A[i] - U */ *tmpc = *tmpa++ - u; /* U = carry bit of T[i] */ u = *tmpc >> ((mp_digit)(CHAR_BIT * sizeof (mp_digit) - 1)); /* Clear carry from T[i] */ *tmpc++ &= MP_MASK;
*/
4.2 Addition and Subtraction 073 074 075 076 077 078 079 080 081 082 083 084 085
63
} /* clear digits above used (we may not have grown result above) */ for (i = c->used; i < olduse; i++) { *tmpc++ = 0; } } mp_clamp (c); return MP_OKAY; }
Like low level addition we “sort” the inputs, except in this case, the sorting is hard coded (lines 25 and 26). In reality, the min and max variables are only aliases and are only used to make the source code easier to read. Again, the pointer alias optimization is used within this algorithm. The aliases tmpa, tmpb, and tmpc are initialized (lines 42, 43 and 44) for a, b, and c, respectively. The first subtraction loop (lines 47 through 61) subtracts digits from both inputs until the smaller of the two has been exhausted. As remarked earlier, there is an implementation reason for using the “awkward” method of extracting the carry (line 57). The traditional method for extracting the carry would be to shift by lg(β) positions and logically AND the least significant bit. The AND operation is required because all of the bits above the lg(β)’th bit will be set to one after a carry occurs from subtraction. This carry extraction requires two relatively cheap operations to extract the carry. The other method is to simply shift the most significant bit to the least significant bit, thus extracting the carry with a single cheap operation. This optimization only works on twos complement machines, which is a safe assumption to make. If a has a larger magnitude than b, an additional loop (lines 64 through 73) is required to propagate the carry through a and copy the result to c.
4.2.3
High Level Addition
Now that both lower level addition and subtraction algorithms have been established, an effective high level signed addition algorithm can be established. This high level addition algorithm will be what other algorithms and developers will use to perform addition of mp int data types.
64
www.syngress.com
Recall from section 5.2 that an mp int represents an integer with an unsigned mantissa (the array of digits) and a sign flag. A high level addition is actually performed as a series of eight separate cases that can be optimized down to three unique cases. Algorithm mp add. Input. Two mp ints a and b Output. The signed addition c = a + b. 1. if a.sign = b.sign then do 1.1 c.sign ← a.sign 1.2 c ← |a| + |b| (s mp add ) 2. else do 2.1 if |a| < |b| then do (mp cmp mag) 2.1.1 c.sign ← b.sign 2.1.2 c ← |b| − |a| (s mp sub) 2.2 else do 2.2.1 c.sign ← a.sign 2.2.2 c ← |a| − |b| 3. Return(MP OKAY ). Figure 4.3: Algorithm mp add Algorithm mp add. This algorithm performs the signed addition of two mp int variables. There is no reference algorithm to draw upon from either [1] or [2] since they both only provide unsigned operations. The algorithm is fairly straightforward but restricted, since subtraction can only produce positive results (Figure 4.3). Figure 4.4 lists the eight possible input combinations and is sorted to show that only three specific cases need to be handled. The return code of the unsigned operations at steps 1.2, 2.1.2, and 2.2.2 are forwarded to step 3 to check for errors. This simplifies the description of the algorithm considerably and best follows how the implementation actually was achieved. Also note how the sign is set before the unsigned addition or subtraction is performed. Recall from the descriptions of algorithms s mp add and s mp sub that the mp clamp function is used at the end to trim excess digits. The mp clamp algorithm will set the sign to MP ZPOS when the used digit count reaches zero.
65
4.2 Addition and Subtraction Sign of a + + − −
Sign of b + + − −
|a| > |b| Yes No Yes No
Unsigned Operation c=a+b c=a+b c=a+b c=a+b
Result Sign Flag a.sign a.sign a.sign a.sign
+ −
− +
No No
c=b−a c=b−a
b.sign b.sign
+ −
− +
Yes Yes
c=a−b c=a−b
a.sign a.sign
Figure 4.4: Addition Guide Chart For example, consider performing −a + a with algorithm mp add. By the description of the algorithm the sign is set to MP NEG, which would produce a result of −0. However, since the sign is set first, then the unsigned addition is performed, the subsequent usage of algorithm mp clamp within algorithm s mp add will force −0 to become 0. File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035
bn mp add.c /* high level addition (handles signs) */ int mp_add (mp_int * a, mp_int * b, mp_int * c) { int sa, sb, res; /* get sign of both inputs */ sa = a->sign; sb = b->sign; /* handle two cases, not four */ if (sa == sb) { /* both positive or both negative */ /* add their magnitudes, copy the sign */ c->sign = sa; res = s_mp_add (a, b, c); } else { /* one positive, the other negative */ /* subtract the one with the greater magnitude from */
66 036 037 038 039 040 041 042 043 044 045 046 047 048 049
www.syngress.com /* the one of the lesser magnitude. The result gets */ /* the sign of the one with the greater magnitude. */ if (mp_cmp_mag (a, b) == MP_LT) { c->sign = sb; res = s_mp_sub (b, a, c); } else { c->sign = sa; res = s_mp_sub (a, b, c); } } return res; }
The source code follows the algorithm fairly closely. The most notable new source code addition is the usage of the res integer variable, which is used to pass the result of the unsigned operations forward. Unlike in the algorithm, the variable res is merely returned as is without explicitly checking it and returning the constant MP OKAY. The observation is this algorithm will succeed or fail only if the lower level functions do so. Returning their return code is sufficient.
4.2.4
High Level Subtraction
The high level signed subtraction algorithm is essentially the same as the high level signed addition algorithm.
67
4.2 Addition and Subtraction Algorithm mp sub. Input. Two mp ints a and b Output. The signed subtraction c = a − b. 1. if a.sign 6= b.sign then do 1.1 c.sign ← a.sign 1.2 c ← |a| + |b| (s mp add ) 2. else do 2.1 if |a| ≥ |b| then do (mp cmp mag) 2.1.1 c.sign ← a.sign 2.1.2 c ← |a| − |b| (s mp sub) 2.2 else do M P ZP OS if a.sign = M P N EG 2.2.1 c.sign ← M P N EG otherwise 2.2.2 c ← |b| − |a| 3. Return(MP OKAY ). Figure 4.5: Algorithm mp sub
Algorithm mp sub. This algorithm performs the signed subtraction of two inputs (Figure 4.5). Similar to algorithm mp add there is no reference in either [1] or [2]. Also this algorithm is restricted by algorithm s mp sub. Figure 4.6 lists the eight possible inputs and the operations required. Sign of a + + − −
Sign of b − − + +
|a| ≥ |b| Yes No Yes No
Unsigned Operation c=a+b c=a+b c=a+b c=a+b
Result Sign Flag a.sign a.sign a.sign a.sign
+ −
+ −
Yes Yes
c=a−b c=a−b
a.sign a.sign
+ −
+ −
No No
c=b−a c=b−a
opposite of a.sign opposite of a.sign
Figure 4.6: Subtraction Guide Chart
68
www.syngress.com
Similar to the case of algorithm mp add, the sign is set first before the unsigned addition or subtraction, to prevent the algorithm from producing −a − −a = −0 as a result. File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053
bn mp sub.c /* high level subtraction (handles signs) */ int mp_sub (mp_int * a, mp_int * b, mp_int * c) { int sa, sb, res; sa = a->sign; sb = b->sign; if (sa != sb) { /* subtract a negative from a positive, OR */ /* subtract a positive from a negative. */ /* In either case, ADD their magnitudes, */ /* and use the sign of the first number. */ c->sign = sa; res = s_mp_add (a, b, c); } else { /* subtract a positive from a positive, OR */ /* subtract a negative from a negative. */ /* First, take the difference between their */ /* magnitudes, then... */ if (mp_cmp_mag (a, b) != MP_LT) { /* Copy the sign from the first */ c->sign = sa; /* The first has a larger or equal magnitude */ res = s_mp_sub (a, b, c); } else { /* The result has the *opposite* sign from */ /* the first number. */ c->sign = (sa == MP_ZPOS) ? MP_NEG : MP_ZPOS; /* The second has a larger magnitude */ res = s_mp_sub (b, a, c); } } return res; }
4.3 Bit and Digit Shifting
69
Much like the implementation of algorithm mp add, the variable res is used to catch the return code of the unsigned addition or subtraction operations and forward it to the end of the function. On line 39, the “not equal to” MP LT expression is used to emulate a “greater than or equal to” comparison.
4.3
Bit and Digit Shifting
It is quite common to think of P a multiple precision integer as a polynomial in x; n−1 that is, y = f (β) where f (x) = i=0 ai xi . This notation arises within discussion of Montgomery and Diminished Radix Reduction, and Karatsuba multiplication and squaring. To facilitate operations on polynomials in x as above, a series of simple “digit” algorithms have to be established. That is to shift the digits left or right and to shift individual bits of the digits left and right. It is important to note that not all “shift” operations are on radix-β digits.
4.3.1
Multiplication by Two
In a binary system where the radix is a power of two, multiplication by two arises often in other algorithms and is a fairly efficient operation to perform. A single precision logical shift left is sufficient to multiply a single digit by two.
70
www.syngress.com Algorithm mp mul 2. Input. One mp int a Output. b = 2a. 1. 2. 3. 4. 5.
If b.alloc < a.used + 1 then grow b to hold a.used + 1 digits. (mp grow ) oldused ← b.used b.used ← a.used r←0 for n from 0 to a.used − 1 do 5.1 rr ← an >> (lg(β) − 1) 5.2 bn ← (an used + 1) { if ((res = mp_grow (b, a->used + 1)) != MP_OKAY) { return res; } } oldused = b->used; b->used = a->used; { register mp_digit r, rr, *tmpa, *tmpb; /* alias for source */ tmpa = a->dp; /* alias for dest */ tmpb = b->dp; /* carry */ r = 0; for (x = 0; x < a->used; x++) { /* get what will be the *next* carry bit from the * MSB of the current digit */ rr = *tmpa >> ((mp_digit)(DIGIT_BIT - 1)); /* now shift up this digit, add in the carry [from the previous] */ *tmpb++ = ((*tmpa++ used); } /* now zero any excess digits on the destination * that we didn’t write to */ tmpb = b->dp + b->used; for (x = b->used; x < oldused; x++) { *tmpb++ = 0; } } b->sign = a->sign; return MP_OKAY; }
This implementation is essentially an optimized implementation of s mp add for the case of doubling an input. The only noteworthy difference is the use of the logical shift operator on line 52 to perform a single precision doubling.
4.3.2
Division by Two
A division by two can just as easily be accomplished with a logical shift right, as multiplication by two can be with a logical shift left.
4.3 Bit and Digit Shifting
73
Algorithm mp div 2. Input. One mp int a Output. b = a/2. 1. 2. 3. 4. 5. 6.
If b.alloc < a.used then grow b to hold a.used digits. (mp grow ) If the reallocation failed return(MP MEM ). oldused ← b.used b.used ← a.used r←0 for n from b.used − 1 to 0 do 6.1 rr ← an (mod 2) 6.2 bn ← (an >> 1) + (r alloc < a->used) { if ((res = mp_grow (b, a->used)) != MP_OKAY) { return res; } } oldused = b->used; b->used = a->used; { register mp_digit r, rr, *tmpa, *tmpb; /* source alias */ tmpa = a->dp + b->used - 1; /* dest alias */ tmpb = b->dp + b->used - 1; /* carry */ r = 0; for (x = b->used - 1; x >= 0; x--) { /* get the carry for the next iteration */ rr = *tmpa & 1; /* shift the current digit, add in carry and store */ *tmpb-- = (*tmpa-- >> 1) | (r dp + b->used; for (x = b->used; x < oldused; x++) { *tmpb++ = 0; } } b->sign = a->sign; mp_clamp (b); return MP_OKAY; }
4.4 Polynomial Basis Operations
4.4
75
Polynomial Basis Operations
Recall from section 4.3 that any integer can be represented as a polynomial in x as y = f (β). Such a representation is also known as the polynomial basis [3, pp. 48]. Given such a notation, a multiplication or division by x amounts to shifting whole digits a single place. The need for such operations arises in several other higher level algorithms such as Barrett and Montgomery reduction, integer division, and Karatsuba multiplication. Converting from an array of digits to polynomialP basis is very simple. Consider 2 i the integer y ≡ (a2 , a1 , a0 )β and recall that y = i=0 ai β . Simply replace β with x and the expression is in polynomial basis. For example, f (x) = 8x + 9 is the polynomial basis representation for 89 using radix ten. That is, f (10) = 8(10) + 9 = 89.
4.4.1
Multiplication by x
Given a polynomial in x such as f (x) = an xn + an−1 xn−1 + ... + a0 , multiplying by x amounts to shifting the coefficients up one degree. In this case, f (x) · x = an xn+1 + an−1 xn + ... + a0 x. From a scalar basis point of view, multiplying by x is equivalent to multiplying by the integer β.
76
www.syngress.com Algorithm mp lshd. Input. One mp int a and an integer b Output. a ← a · β b (equivalent to multiplication by xb ). 1. 2. 3. 4. 5. 6. 7.
If b ≤ 0 then return(MP OKAY ). If a.alloc < a.used + b then grow a to at least a.used + b digits. (mp grow ). If the reallocation failed return(MP MEM ). a.used ← a.used + b i ← a.used − 1 j ← a.used − 1 − b for n from a.used − 1 to b do 7.1 ai ← aj 7.2 i ← i − 1 7.3 j ← j − 1 8. for n from 0 to b − 1 do 8.1 an ← 0 9. Return(MP OKAY ).
Figure 4.9: Algorithm mp lshd Algorithm mp lshd. This algorithm multiplies an mp int by the b’th power of x. This is equivalent to multiplying by β b . The algorithm differs from the other algorithms presented so far as it performs the operation in place instead of storing the result in a separate location. The motivation behind this change is the way this function is typically used. Algorithms such as mp add store the result in an optionally different third mp int because the original inputs are often still required. Algorithm mp lshd (and similarly algorithm mp rshd ) is typically used on values where the original value is no longer required. The algorithm will return success immediately if b ≤ 0, since the rest of algorithm is only valid when b > 0 (Figure 4.9). First, the destination a is grown as required to accommodate the result. The counters i and j are used to form a sliding window over the digits of a of length b (Figure 4.10). The head of the sliding window is at i (the leading digit ) and the tail at j (the trailing digit ). The loop in step 7 copies the digit from the tail to the head. In each iteration, the window is moved down one digit. The last loop in step 8 sets the lower b digits to zero.
4.4 Polynomial Basis Operations
Figure 4.10: Sliding Window Movement File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041
bn mp lshd.c /* shift left a certain amount of digits */ int mp_lshd (mp_int * a, int b) { int x, res; /* if its less than zero return */ if (b alloc < a->used + b) { if ((res = mp_grow (a, a->used + b)) != MP_OKAY) { return res; } } { register mp_digit *top, *bottom; /* increment the used by the shift amount then copy upwards */ a->used += b; /* top */
77
78 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063
www.syngress.com top = a->dp + a->used - 1; /* base */ bottom = a->dp + a->used - 1 - b; /* much like mp_rshd this is implemented using a sliding window * except the window goes the otherway around. Copying from * the bottom to the top. see bn_mp_rshd.c for more info. */ for (x = a->used - 1; x >= b; x--) { *top-- = *bottom--; } /* zero the lower digits */ top = a->dp; for (x = 0; x < b; x++) { *top++ = 0; } } return MP_OKAY; }
The if statement (line 24) ensures that the b variable is greater than zero since we do not interpret negative shift counts properly. The used count is incremented by b before the copy loop begins. This eliminates the need for an additional variable in the for loop. The variable top (line 42) is an alias for the leading digit, while bottom (line 45) is an alias for the trailing edge. The aliases form a window of exactly b digits over the input.
4.4.2
Division by x
Division by powers of x is easily achieved by shifting the digits right and removing any that will end up to the right of the zero’th digit.
4.4 Polynomial Basis Operations
79
Algorithm mp rshd. Input. One mp int a and an integer b Output. a ← a/β b (Divide by xb ). 1. If b ≤ 0 then return. 2. If a.used ≤ b then do 2.1 Zero a. (mp zero). 2.2 Return. 3. i ← 0 4. j ← b 5. for n from 0 to a.used − b − 1 do 5.1 ai ← aj 5.2 i ← i + 1 5.3 j ← j + 1 6. for n from a.used − b to a.used − 1 do 6.1 an ← 0 7. a.used ← a.used − b 8. Return.
Figure 4.11: Algorithm mp rshd Algorithm mp rshd. This algorithm divides the input in place by the b’th power of x. It is analogous to dividing by a β b but much quicker since it does not require single precision division. This algorithm does not actually return an error code as it cannot fail (Figure 4.11). If the input b is less than one, the algorithm quickly returns without performing any work. If the used count is less than or equal to the shift count b then it will simply zero the input and return. After the trivial cases of inputs have been handled, the sliding window is set up. Much like the case of algorithm mp lshd, a sliding window that is b digits wide is used to copy the digits. Unlike mp lshd, the window slides in the opposite direction from the trailing to the leading digit. In addition, the digits are copied from the leading to the trailing edge. Once the window copy is complete, the upper digits must be zeroed and the used count decremented. File: bn mp rshd.c 018 /* shift right a certain amount of digits */ 019 void mp_rshd (mp_int * a, int b)
80 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060
www.syngress.com { int
x;
/* if b used dp; /* top [offset into digits] */ top = a->dp + b; /* * * * *
this is implemented as a sliding window where the window is b-digits long and digits from the top of the window are copied to the bottom e.g.
b-2 | b-1 | b0 | b1 | b2 | ... | bb | /\ | \-------------------/ */ for (x = 0; x < (a->used - b); x++) { *bottom++ = *top++; } /* zero the top digits */ for (; x < a->used; x++) {
----> ----> ---->
4.5 Powers of Two 061 062 063 064 065 066 067 068
81
*bottom++ = 0; } } /* remove excess digits */ a->used -= b; }
The only noteworthy element of this routine is the lack of a return type since it cannot fail. Like mp lshd(), we form a sliding window except we copy in the other direction. After the window (line 60), we then zero the upper digits of the input to make sure the result is correct.
4.5
Powers of Two
Now that algorithms for moving single bits and whole digits exist, algorithms for moving the “in between” distances are required. For example, to quickly multiply by 2k for any k without using a full multiplier algorithm would prove useful. Instead of performing single shifts k times to achieve a multiplication by 2±k , a mixture of whole digit shifting and partial digit shifting is employed.
82
4.5.1
www.syngress.com
Multiplication by Power of Two Algorithm mp mul 2d. Input. One mp int a and an integer b Output. c ← a · 2b . 1. 2. 3. 4.
c ← a. (mp copy) If c.alloc < c.used + ⌊b/lg(β)⌋ + 2 then grow c accordingly. If the reallocation failed return(MP MEM ). If b ≥ lg(β) then 4.1 c ← c · β ⌊b/lg(β)⌋ (mp lshd ). 4.2 If step 4.1 failed return(MP MEM ). 5. d ← b (mod lg(β)) 6. If d 6= 0 then do 6.1 mask ← 2d 6.2 r ← 0 6.3 for n from 0 to c.used − 1 do 6.3.1 rr ← cn >> (lg(β) − d) (mod mask) 6.3.2 cn ← (cn 0 then do 6.4.1 cc.used ← r 6.4.2 c.used ← c.used + 1 7. Return(MP OKAY ).
Figure 4.12: Algorithm mp mul 2d Algorithm mp mul 2d. This algorithm multiplies a by 2b and stores the result in c. The algorithm uses algorithm mp lshd and a derivative of algorithm mp mul 2 to quickly compute the product (Figure 4.12). First, the algorithm will multiply a by x⌊b/lg(β)⌋ , which will ensure that the remainder multiplicand is less than β. For example, if b = 37 and β = 228 , then this step will multiply by x leaving a multiplication by 237−28 = 29 left. After the digits have been shifted appropriately, at most lg(β) − 1 shifts are left to perform. Step 5 calculates the number of remaining shifts required. If it is non-zero, a modified shift loop is used to calculate the remaining product. Essentially, the loop is a generic version of algorithm mp mul 2 designed to handle any shift count in the range 1 ≤ x < lg(β). The mask variable is used to extract the upper d bits to form the carry for the next iteration.
4.5 Powers of Two
83
This algorithm is loosely measured as a O(2n) algorithm, which means that if the input is n-digits, it takes 2n “time” to complete. It is possible to optimize this algorithm down to a O(n) algorithm at a cost of making the algorithm slightly harder to follow. File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052
bn mp mul 2d.c /* shift left by a certain bit count */ int mp_mul_2d (mp_int * a, int b, mp_int * c) { mp_digit d; int res; /* copy */ if (a != c) { if ((res = mp_copy (a, c)) != MP_OKAY) { return res; } } if (c->alloc < (int)(c->used + b/DIGIT_BIT + 1)) { if ((res = mp_grow (c, c->used + b / DIGIT_BIT + 1)) != MP_OKAY) { return res; } } /* shift by as many digits in the bit count */ if (b >= (int)DIGIT_BIT) { if ((res = mp_lshd (c, b / DIGIT_BIT)) != MP_OKAY) { return res; } } /* shift any bit count < DIGIT_BIT */ d = (mp_digit) (b % DIGIT_BIT); if (d != 0) { register mp_digit *tmpc, shift, mask, r, rr; register int x; /* bitmask for carries */ mask = (((mp_digit)1) dp; /* carry */ r = 0; for (x = 0; x < c->used; x++) { /* get the higher bits of the current word */ rr = (*tmpc >> shift) & mask; /* shift the current word and OR in the carry */ *tmpc = ((*tmpc dp[(c->used)++] = r; } } mp_clamp (c); return MP_OKAY; }
The shifting is performed in place, which means the first step (line 25) is to copy the input to the destination. We avoid calling mp copy() by making sure the mp ints are different. The destination then has to be grown (line 32) to accommodate the result. If the shift count b is larger than lg(β), then a call to mp lshd() is used to handle all the multiples of lg(β), leaving only a remaining shift of lg(β) − 1 or fewer bits left. Inside the actual shift loop (lines 61 to 71) we make use of pre– computed values shif t and mask to extract the carry bit(s) to pass into the next iteration of the loop. The r and rr variables form a chain between consecutive iterations to propagate the carry.
85
4.5 Powers of Two
4.5.2
Division by Power of Two Algorithm mp div 2d. Input. One mp int a and an integer b Output. c ← ⌊a/2b ⌋, d ← a (mod 2b ). 1. If b ≤ 0 then do 1.1 c ← a (mp copy) 1.2 d ← 0 (mp zero) 1.3 Return(MP OKAY ). 2. c ← a 3. d ← a (mod 2b ) (mp mod 2d ) 4. If b ≥ lg(β) then do 4.1 c ← ⌊c/β ⌊b/lg(β)⌋ ⌋ (mp rshd ). 5. k ← b (mod lg(β)) 6. If k 6= 0 then do 6.1 mask ← 2k 6.2 r ← 0 6.3 for n from c.used − 1 to 0 do 6.3.1 rr ← cn (mod mask) 6.3.2 cn ← (cn >> k) + (r used - 1; x >= 0; x--) { /* get the lower bits of this word in a temp */ rr = *tmpc & mask; /* shift the current word and mix in the carry bits from the previous word */ *tmpc = (*tmpc >> D) | (r a.used · lg(β) then do 2.1 c ← a (mp copy) 2.2 Return the result of step 2.1. 3. c ← a 4. If step 3 failed return(MP MEM ). 5. for n from ⌈b/lg(β)⌉ to c.used do 5.1 cn ← 0 6. k ← b (mod lg(β)) 7. c⌊b/lg(β)⌋ ← c⌊b/lg(β)⌋ (mod 2k ). 8. Clamp excess digits of c. (mp clamp) 9. Return(MP OKAY ).
Figure 4.14: Algorithm mp mod 2d Algorithm mp mod 2d. This algorithm will quickly calculate the value of a (mod 2b ). First, if b is less than or equal to zero the result is set to zero. If b is greater than the number of bits in a, then it simply copies a to c and returns. Otherwise, a is copied to b, leading digits are removed and the remaining leading digit is trimmed to the exact bit count (Figure 4.14). File: 018 019 020 021 022 023
bn mp mod 2d.c /* calc a value mod 2**b */ int mp_mod_2d (mp_int * a, int b, mp_int * c) { int x, res;
4.5 Powers of Two 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053
89
/* if b is used * DIGIT_BIT)) { res = mp_copy (a, c); return res; } /* copy */ if ((res = mp_copy (a, c)) != MP_OKAY) { return res; } /* zero digits above the last digit of the modulus */ for (x = (b / DIGIT_BIT) + ((b % DIGIT_BIT) == 0 ? 0 : 1); x < c->used; x++) { c->dp[x] = 0; } /* clear the digit that is not completely outside/inside the modulus */ c->dp[b / DIGIT_BIT] &= (mp_digit) ((((mp_digit) 1) 2 · β 2 . The constant δ = 2α−2lg(β) will represent the maximal weight of any column in a product (see 6.2 for more information).
93
5.2 Multiplication Algorithm s mp mul digs. Input. mp int a, mp int b and an integer digs Output. c ← |a| · |b| (mod β digs ). 1. If min(a.used, b.used) < δ then do 1.1 Calculate c = |a| · |b| by the Comba method (see algorithm 5.5). 1.2 Return the result of step 1.1 Allocate and initialize a temporary mp int. 2. Init t to be of size digs 3. If step 2 failed return(MP MEM ). 4. t.used ← digs Compute the product. 5. for ix from 0 to a.used − 1 do 5.1 u ← 0 5.2 pb ← min(b.used, digs − ix) 5.3 If pb < 1 then goto step 6. 5.4 for iy from 0 to pb − 1 do 5.4.1 rˆ ← tiy+ix + aix · biy + u 5.4.2 tiy+ix ← rˆ (mod β) 5.4.3 u ← ⌊ˆ r /β⌋ 5.5 if ix + pb < digs then do 5.5.1 tix+pb ← u 6. Clamp excess digits of t. 7. Swap c with t 8. Clear t 9. Return(MP OKAY ).
Figure 5.1: Algorithm s mp mul digs Algorithm s mp mul digs. This algorithm computes the unsigned product of two inputs a and b, limited to an output precision of digs digits. While it may seem a bit awkward to modify the function from its simple O(n2 ) description, the usefulness of partial multipliers will arise in a subsequent algorithm. The algorithm is loosely based on algorithm 14.12 from [2, pp. 595] and is similar to Algorithm M of Knuth [1, pp. 268]. Algorithm s mp mul digs differs from these cited references since it can produce a variable output precision regardless of the precision of the inputs (Figure 5.1). The first thing this algorithm checks for is whether a Comba multiplier can
94
www.syngress.com
be used instead. If the minimum digit count of either input is less than δ, then the Comba method may be used instead. After the Comba method is ruled out, the baseline algorithm begins. A temporary mp int variable t is used to hold the intermediate result of the product. This allows the algorithm to be used to compute products when either a = c or b = c without overwriting the inputs. All of step 5 is the infamous O(n2 ) multiplication loop slightly modified to only produce up to digs digits of output. The pb variable is given the count of digits to read from b inside the nested loop. If pb ≤ 1, then no more output digits can be produced and the algorithm will exit the loop. The best way to think of the loops are as a series of pb × 1 multiplications. That is, in each pass of the innermost loop, aix is multiplied against b and the result is added (with an appropriate shift ) to t. For example, consider multiplying 576 by 241. That is equivalent to computing 100 (1)(576) + 101 (4)(576) + 102 (2)(576), which is best visualized in Figure 5.2.
×
1
2 3
3 8
5 2
7 4
6 1
5 6 8
7 1 1
6 6 6
100 (1)(576) 101 (4)(576) + 100 (1)(576) 102 (2)(576) + 101 (4)(576) + 100 (1)(576)
Figure 5.2: Long-Hand Multiplication Diagram Each row of the product is added to the result after being shifted to the left (multiplied by a power of the radix ) by the appropriate count. That is, in pass ix of the inner loop the product is added starting at the ix’th digit of the result. Step 5.4.1 introduces the hat symbol (e.g., rˆ), which represents a double precision variable. The multiplication on that step is assumed to be a double wide output single precision multiplication. That is, two single precision variables are multiplied to produce a double precision result. The step is somewhat optimized from a long-hand multiplication algorithm because the carry from the addition in step 5.4.1 is propagated through the nested loop. If the carry were not propagated immediately, it would overflow the single precision digit tix+iy and the result would be lost. At step 5.5 the nested loop is finished and any carry that was left over should be forwarded. The carry does not have to be added to the ix + pb’th digit since
5.2 Multiplication
95
that digit is assumed to be zero at this point. However, if ix + pb ≥ digs, the carry is not set, as it would make the result exceed the precision requested. File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054
bn s mp mul digs.c /* multiplies |a| * |b| and only computes up to digs digits of result * HAC pp. 595, Algorithm 14.12 Modified so you can control how * many digits of output are created. */ int s_mp_mul_digs (mp_int * a, mp_int * b, mp_int * c, int digs) { mp_int t; int res, pa, pb, ix, iy; mp_digit u; mp_word r; mp_digit tmpx, *tmpt, *tmpy; /* can we use the fast multiplier? */ if (((digs) < MP_WARRAY) && MIN (a->used, b->used) < (1 used; for (ix = 0; ix < pa; ix++) { /* set the carry to zero */ u = 0; /* limit ourselves to making digs digits of output */ pb = MIN (b->used, digs - ix); /* setup some aliases */ /* copy of the digit from a used within the nested loop */ tmpx = a->dp[ix];
96 055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074 075 076 077 078 079 080 081 082 083 084 085 086
www.syngress.com /* an alias for the destination shifted ix places */ tmpt = t.dp + ix; /* an alias for the digits of b */ tmpy = b->dp; /* compute the columns of the output and propagate the carry */ for (iy = 0; iy < pb; iy++) { /* compute the column as a mp_word */ r = ((mp_word)*tmpt) + ((mp_word)tmpx) * ((mp_word)*tmpy++) + ((mp_word) u); /* the new column is the lower part of the result */ *tmpt++ = (mp_digit) (r & ((mp_word) MP_MASK)); /* get the carry word from the result */ u = (mp_digit) (r >> ((mp_word) DIGIT_BIT)); } /* set carry if it is placed below digs */ if (ix + iy < digs) { *tmpt = u; } } mp_clamp (&t); mp_exch (&t, c); mp_clear (&t); return MP_OKAY; }
First, we determine (line 31) if the Comba method can be used since it is faster. The conditions for using the Comba routine are that min(a.used, b.used) < δ and the number of digits of output is less than MP WARRAY. This new constant is used to control the stack usage in the Comba routines. By default it is set to δ, but can be reduced when memory is at a premium. If we cannot use the Comba method we proceed to set up the baseline routine. We allocate the the destination mp int t (line 37) to the exact size of the output to avoid further reallocations. At this point, we now begin the O(n2 ) loop.
97
5.2 Multiplication
This implementation of multiplication has the caveat that it can be trimmed to only produce a variable number of digits as output. In each iteration of the outer loop the pb variable is set (line 49) to the maximum number of inner loop iterations. Inside the inner loop we calculate rˆ as the mp word product of the two mp digits and the addition of the carry from the previous iteration. A particularly important observation is that most modern optimizing C compilers (GCC for instance) can recognize that an N × N → 2N multiplication is all that is required for the product. In x86 terms, for example, this means using the MUL instruction. Each digit of the product is stored in turn (line 69) and the carry propagated (line 72) to the next iteration.
5.2.2
Faster Multiplication by the “Comba” Method
One of the huge drawbacks of the “baseline” algorithms is that at the O(n2 ) level the carry must be computed and propagated upwards. This makes the nested loop very sequential and hard to unroll and implement in parallel. The “Comba” [4] method is named after little known (in cryptographic venues) Paul G. Comba, who described a method of implementing fast multipliers that do not require nested carry fix-up operations. As an interesting aside it seems that Paul Barrett describes a similar technique in his 1986 paper [6] written five years before. At the heart of the Comba technique is again the long-hand algorithm, except in this case a slight twist is placed on how the columns of the result are produced. In the standard long-hand algorithm, rows of products are produced and then added together to form the result. In the baseline algorithm, the columns are added together after each iteration to get the result instantaneously. In the Comba algorithm, the columns of the result are produced entirely independently of each other; that is, at the O(n2 ) level a simple multiplication and addition step is performed. The carries of the columns are propagated after the nested loop to reduce the amount of work required. Succinctly, the first step of the algorithm is to compute the product vector ~x as follows: X ai bj , ∀n ∈ {0, 1, 2, . . . , i + j} (5.1) ~xn = i+j=n
where ~xn is the n′ th column of the output vector. Consider Figure 5.3, which computes the vector ~x for the multiplication of 576 and 241.
98
www.syngress.com
×
2 · 5 = 10 10
4 · 5 = 20 2 · 7 + 20 = 34 34
5 2 1·5=5 4 · 7 + 5 = 33 2 · 6 + 33 = 45 45
7 4 1·7=7 4 · 6 + 7 = 31 31 31
6 1 1·6=6 6 6 6
First Input Second Input First pass Second pass Third pass Final Result
Figure 5.3: Comba Multiplication Diagram At this point the vector x = h10, 34, 45, 31, 6i is the result of the first step of the Comba multiplier. Now the columns must be fixed by propagating the carry upwards. The resultant vector will have one extra dimension over the input vector, which is congruent to adding a leading zero digit (Figure 5.4). Algorithm Comba Fixup. Input. Vector ~ x of dimension k Output. Vector ~ x such that the carries have been propagated. 1. for n from 0 to k − 1 do 1.1 ~ xn+1 ← ~ xn+1 + ⌊~ xn /β⌋ 1.2 ~ xn ← ~ xn (mod β) 2. Return(~ x).
Figure 5.4: Algorithm Comba Fixup With that algorithm and k = 5 and β = 10 the ~x = h1, 3, 8, 8, 1, 6i vector is produced. In this case, 241 · 576 is in fact 138816 and the procedure succeeded. If the algorithm is correct and, as will be demonstrated shortly, more efficient than the baseline algorithm, why not simply always use this algorithm? Column Weight. At the nested O(n2 ) level the Comba method adds the product of two single precision variables to each column of the output independently. A serious obstacle is if the carry is lost, due to lack of precision before the algorithm has a chance to fix the carries. For example, in the multiplication of two three-digit numbers, the third column of output will be the sum of three single precision multiplications. If the precision of the accumulator for the output digits is less than 3 · (β − 1)2 ,
99
5.2 Multiplication
then an overflow can occur and the carry information will be lost. For any m and n digit inputs the maximum weight of any column is min(m, n), which is fairly obvious. The maximum number of terms in any column of a product is known as the “column weight” and strictly governs when the algorithm can be used. Recall that a double precision type has α bits of resolution and a single precision digit has lg(β) bits of precision. Given these two quantities we must not violate: 2
k · (β − 1) < 2α
(5.2)
k · β 2 − 2β + 1 < 2α
(5.3)
which reduces to
Let ρ = lg(β) represent the number of bits in a single precision digit. By further re-arrangement of the equation the final solution is found. k
alloc < digs) { if ((res = mp_grow (c, digs)) != MP_OKAY) { return res; } } /* number of output digits to produce */ pa = MIN(digs, a->used + b->used); /* clear the _W = 0; for (ix = 0; int int mp_digit
carry */ ix < pa; ix++) { tx, ty; iy; *tmpx, *tmpy;
/* get offsets into the two bignums */ ty = MIN(b->used-1, ix); tx = ix - ty; /* setup temp aliases */ tmpx = a->dp + tx; tmpy = b->dp + ty; /* this is the number of times the loop will iterate, essentially while (tx++ < a->used && ty-- >= 0) { ... } */ iy = MIN(a->used-tx, ty+1); /* execute loop */ for (iz = 0; iz < iy; ++iz) { _W += ((mp_word)*tmpx++)*((mp_word)*tmpy--); } /* store term */
5.2 Multiplication 076 077 078 079 080 081 082 083 084 085 086 087 088 089 090 091 092 093 094 095 096 097 098 099 100 101 102
103
W[ix] = ((mp_digit)_W) & MP_MASK; /* make next carry */ _W = _W >> ((mp_word)DIGIT_BIT); } /* setup dest */ olduse = c->used; c->used = pa; { register mp_digit *tmpc; tmpc = c->dp; for (ix = 0; ix < pa+1; ix++) { /* now extract the previous digit [below the carry] */ *tmpc++ = W[ix]; } /* clear unused digits [that existed in the old copy of c] */ for (; ix < olduse; ix++) { *tmpc++ = 0; } } mp_clamp (c); return MP_OKAY; }
As per the pseudo–code we first calculate pa (line 48) as the number of digits to output. Next, we begin the outer loop to produce the individual columns of the product. We use the two aliases tmpx and tmpy (lines 62, 63) to point inside the two multiplicands quickly. The inner loop (lines 71 to 73) of this implementation is where the trade–off come into play. Originally, this Comba implementation was “row–major,” which means it adds to each of the columns in each pass. After the outer loop it would then fix the carries. This was very fast, except it had an annoying drawback. You had to read an mp word and two mp digits and write one mp word per iteration. On processors such as the Athlon XP and P4 this did not matter much since the cache bandwidth is very high and it can keep the ALU fed with data. It did, however, matter on older and embedded CPUs where cache is often slower and
104
www.syngress.com
often does not exist. This new algorithm only performs two reads per iteration ˆ to a CPU register. under the assumption that the compiler has aliased W ˆ (lines After the inner loop we store the current accumulator in W and shift W 76, 79) to forward it as a carry for the next pass. After the outer loop we use the final carry (line 76) as the last digit of the product.
5.2.3
Even Faster Multiplication
In the realm of O(n2 ) multipliers, we can actually do better than Comba multipliers. In the case of the portable code, only lg(β) bits of each digit are being used. This is only because accessing carry bits from the CPU flags is not efficient in portable C. In the TomsFastMath2 project, a triple–precision register is used to accumulate products. The multiplication algorithm produces digits of the result at a time. The benefit of this algorithm is that we are packing more bits per digit resulting in fewer single precision multiplications. For example, a 1024–bit multiplication on a 32–bit platform involves 1024 single precision multiplications with TomsFastMath and 372 == 1369 with LibTomMath (33% more).
2 See
http://tfm.libtomcrypt.com.
105
5.2 Multiplication Algorithm fast mult. Input. mp int a and mp int b Output. c ← |a| · |b|. Let c0, c1, c2 be three single precision variables. Let tmp represent an mp int. 1. Allocate tmp, an mp int of a.used + b.used digits. (mp init size) 2. pa ← a.used + b.used 3. for ix from 0 to pa − 1 do 3.1 ty ← MIN(ix, b.used − 1) 3.2 tx ← ix − ty 3.3 iy ← MIN(a.used − tx, ty + 1) 3.4 {c2 : c1 : c0} ← {0 : c2 : c1} 3.5 for iz from 0 to iy − 1 do 3.5.1 {c2 : c1 : c0} ← {c2 : c1 : c0} + atx+iz bty−iz 3.6 tmpix ← c0 4. tmp.used ← a.used + b.used 5. Clamp tmp 6. Exchange c and tmp 7. Clear tmp
Figure 5.6: Algorithm fast mult Algorithm fast mult. This algorithm performs a multiplication using the full precision of the digits (Figure 5.6). It is not strictly part of LibTomMath, instead this is part of TomsFastMath. Quite literally the TomsFastMath library was a port of LibTomMath. The first noteworthy change from our LibTomMath conventions is that we are indeed using the full precision of the digits. For example, on a 32–bit platform, a 1024–bit number would require 32 digits to be fully represented (instead of the 37 that LibTomMath would require). The shuffle in step 3.4 is effectively a triple–precision shift right by the size of one digit. Similarly, in step 3.5.1, a double–precision product is being accumulated in the triple–precision array {c2 : c1 : c0}. The TomsFastMath library gets its significant speed increase over LibTomMath not only due to the use of full precision digits, but also the fact that the multipliers are unrolled and use inline assembler. It unrolls the multipliers in steps of 1 through 16, 20, 24, 28, 32, 48 and 64 digits. The unrolling takes considerable space, but the savings in time from not having all of the loop control overhead is
106
www.syngress.com
significant. The use of inline assembler also lets us perform the inner loop with code such as the following x86 assembler. #define MULADD(i, j) asm( "movl %6,%%eax \n\t" "mull %7 \n\t" "addl %%eax,%0 \n\t" "adcl %%edx,%1 \n\t" "adcl $0,%2 \n\t" :"=r"(c0), "=r"(c1), "=r"(c2): "0"(c0), "1"(c1), "2"(c2), "m"(i), "m"(j) : "%eax","%edx","%cc");
\ \ \ \ \ \ \ \ \
This performs the 32×32 multiplication and accumulates it in the 96–bit array {c2 : c1 : c0}, as required in step 3.5.1. A particular feature of the TomsFastMath approach is to use these functional macro blocks instead of hand–tuning the implementation for a given platform. As a result, we can change the macro to the following and produce a math library for ARM processors. #define MULADD(i, j) asm( "UMULL r0,r1,%6,%7 \n\t" "ADDS %0,%0,r0 \n\t" "ADCS %1,%1,r1 \n\t" "ADC %2,%2,#0 \n\t" :"=r"(c0), "=r"(c1), "=r"(c2) : "0"(c0), "1"(c1), "2"(c2), "r"(i), "r"(j) : "r0", "r1", "%cc");
\ \ \ \ \ \ \ \
In total, TomsFastMath supports four distinct hardware architectures covering x86, PPC32 and ARM platforms from a relatively consistent code base. Adding new ports for most platforms is usually a matter of implementing the macros, and then choosing a suitable level of loop unrolling to match the processor cache. When fully unrolled, the x86 assembly code achieves very high performance on the AMD K8 series of processors. An “instructions per cycle” count close to 2 can be observed through 1024–bit multiplications. This means that, on average, more than one processor pipeline is actively processing opcodes. This is particularly significant due to the long delay of the single precision multiplication instruction.
5.2 Multiplication
107
Unfortunately, while this routine could be adapted to LibTomMath (using a more complicated right shift in step 3.4), it would not help as we still have to perform the same number of single precision multiplications. Readers are encouraged to investigate the TomsFastMath library on its own to see how far these optimizations can push performance.
5.2.4
Polynomial Basis Multiplication
To break the O(n2 ) barrier in multiplication requires a completely different look at integer multiplication. In the following algorithms P the use of polynomial P basis representation for two integers a and b as f (x) = ni=0 ai xi and g(x) = ni=0 bi xi , respectively, is required. In this system, both f (x) and g(x) have n + 1 terms and are of the n’th degree. P2n i The product a · b ≡ f (x)g(x) is the polynomial W (x) = i=0 wi x . The coefficients wi will directly yield the desired product when β is substituted for x. The direct solution to solve for the 2n + 1 coefficients requires O(n2 ) time and would in practice be slower than the Comba technique. However, numerical analysis theory indicates that only 2n + 1 distinct points in W (x) are required to determine the values of the 2n + 1 unknown coefficients. This means by finding ζy = W (y) for 2n + 1 small values of y, the coefficients of W (x) can be found with Gaussian elimination. This technique is also occasionally referred to as the interpolation technique [20], since in effect an interpolation based on 2n + 1 points will yield a polynomial equivalent to W (x). The coefficients of the polynomial W (x) are unknown, which makes finding W (y) for any value of y impossible. However, since W (x) = f (x)g(x), the equivalent ζy = f (y)g(y) can be used in its place. The benefit of this technique stems from the fact that f (y) and g(y) are much smaller than either a or b, respectively. As a result, finding the 2n + 1 relations required by multiplying f (y)g(y) involves multiplying integers that are much smaller than either of the inputs. When you are picking points to gather relations, there are always three obvious points to choose, y = 0, 1, and ∞. The ζ0 termP is simply P the product W (0) = w0 = a0 · b0 . The ζ1 term is the product W (1) = ( ni=0 ai ) ( ni=0 bi ). The third point ζ∞ is less obvious but rather simple to explain. The 2n+1’th coefficient of W (x) is numerically equivalent to the most significant column in an integer multiplication. The point at ∞ is used symbolically to represent the most significant column– W (∞) = w2n = an bn . Note that the points at y = 0 and ∞ yield the coefficients w0 and w2n directly. If more points are required they should be of small values and powers of two
108
www.syngress.com
Split into n Parts 2 3 4 5 10 100 1000 10000
Exponent 1.584962501 1.464973520 1.403677461 1.365212389 1.278753601 1.149426538 1.100270931 1.075252070
Notes This is Karatsuba Multiplication. This is Toom-Cook 3-Way Multiplication.
Beyond this point Fourier Transforms are used.
Figure 5.7: Asymptotic Running Time of Polynomial Basis Multiplication such as 2q and the related mirror points (2q )2n · ζ2−q for small values of q. The 2n term “mirror point” stems from the fact that (2q ) · ζ2−q can be calculated in the exact opposite fashion as ζ2q . For example, when n = 2 and q = 1, the following two equations are equivalent to the point ζ2 and its mirror.
ζ2 = f (2)g(2) = (4a2 + 2a1 + a0 )(4b2 + 2b1 + b0 ) 1 1 16 · ζ 12 = 4f ( ) · 4g( ) = (a2 + 2a1 + 4a0 )(b2 + 2b1 + 4b0 ) 2 2
(5.5)
Using such points will allow the values of f (y) and g(y) to be independently calculated using only left shifts. For example, when n = 2 the polynomial f (2q ) is equal to 2q ((2q a2 ) + a1 ) + a0 . This technique of polynomial representation is known as Horner’s method. As a general rule of the algorithm when the inputs are split into n parts each, there are 2n − 1 multiplications. Each multiplication is of multiplicands that have n times fewer digitsthan the inputs. The asymptotic running time of this algorithm is O k lgn (2n−1) for k digit inputs (assuming they have the same number of digits). Figure 5.7 summarizes the exponents for various values of n. At first, it may seem like a good idea to choose n = 1000 since the exponent is approximately 1.1. However, the overhead of solving for the 2001 terms of W (x) will certainly consume any savings the algorithm could offer for all but exceedingly large numbers.
5.2 Multiplication
109
Cutoff Point The polynomial basis multiplication algorithms all require fewer single precision multiplications than a straight Comba approach. However, the algorithms incur an overhead (at the O(n) work level ) since they require a system of equations to be solved. This makes the polynomial basis approach more costly to use with small inputs. Let m represent the number of digits in the multiplicands (assume both multiplicands have the same number of digits). There exists a point y such that when m < y, the polynomial basis algorithms are more costly than Comba; when m = y, they are roughly the same cost; and when m > y, the Comba methods are slower than the polynomial basis algorithms. The exact location of y depends on several key architectural elements of the computer platform in question. 1. The ratio of clock cycles for single precision multiplication versus other simpler operations such as addition, shifting, etc. For example on the AMD Athlon the ratio is roughly 17 : 1, while on the Intel P4 it is 29 : 1. The higher the ratio in favor of multiplication, the lower the cutoff point y will be. 2. The complexity of the linear system of equations (for the coefficients of W (x)) is, generally speaking, as the number of splits grows the complexity grows substantially. Ideally, solving the system will only involve addition, subtraction, and shifting of integers. This directly reflects on the ratio previously mentioned. 3. To a lesser extent, memory bandwidth and function call overhead affect the location of y. Provided the values and code are in the processor cache, this is less of an influence over the cutoff point. A clean cutoff point separation occurs when a point y is found such that all the cutoff point conditions are met. For example, if the point is too low, there will be values of m such that m > y and the Comba method is still faster. Finding the cutoff points is fairly simple when a high–resolution timer is available.
5.2.5
Karatsuba Multiplication
Karatsuba [19] multiplication when originally proposed in 1962 was among the first set of algorithms to break the O(n2 ) barrier for general–purpose multiplication.
110
www.syngress.com
Given two polynomial basis representations f (x) = ax + b and g(x) = cx + d, Karatsuba proved with light algebra [5] that the following polynomial is equivalent to multiplication of the two integers the polynomials represent. f (x) · g(x) = acx2 + ((a + b)(c + d) − (ac + bd))x + bd
(5.6)
Using the observation that ac and bd could be re-used, only three half–sized multiplications would be required to produce the product. Applying this algorithm recursively the work factor becomes O(nlg(3) ), which is substantially better than the work factor O(n2 ) of the Comba technique. It turns out what Karatsuba did not know or at least did not publish was that this is simply polynomial basis multiplication with the points ζ0 , ζ∞ , and ζ1 . Consider the resultant system of equations. ζ0 ζ1 ζ∞
= = =
w2 w2
+
w1
+
w0 w0
By adding the first and last equation to the equation in the middle, the term w1 can be isolated and all three coefficients solved for. The simplicity of this system of equations has made Karatsuba fairly popular. In fact, the cutoff point is often fairly low3 , making it an ideal algorithm to speed up certain public key cryptosystems such as RSA and Diffie-Hellman.
3 With
LibTomMath 0.18 it is 70 and 109 digits for the Intel P4 and AMD Athlon, respectively.
111
5.2 Multiplication Algorithm mp karatsuba mul. Input. mp int a and mp int b Output. c ← |a| · |b| 1. Init the following mp int variables: x0, x1, y0, y1, t1, x0y0, x1y1. 2. If step 2 failed, then return(MP MEM ). Split the input. e.g. a = x1 · β B + x0 3. B ← min(a.used, b.used)/2 4. x0 ← a (mod β B ) (mp mod 2d ) 5. y0 ← b (mod β B ) 6. x1 ← ⌊a/β B ⌋ (mp rshd ) 7. y1 ← ⌊b/β B ⌋ Calculate the three products. 8. x0y0 ← x0 · y0 (mp mul ) 9. x1y1 ← x1 · y1 10. t1 ← x1 + x0 (mp add ) 11. x0 ← y1 + y0 12. t1 ← t1 · x0 Calculate the middle term. 13. x0 ← x0y0 + x1y1 14. t1 ← t1 − x0 (s mp sub) Calculate the final product. 15. t1 ← t1 · β B (mp lshd ) 16. x1y1 ← x1y1 · β 2B 17. t1 ← x0y0 + t1 18. c ← t1 + x1y1 19. Clear all of the temporary variables. 20. Return(MP OKAY ).
Figure 5.8: Algorithm mp karatsuba mul Algorithm mp karatsuba mul. This algorithm computes the unsigned product of two inputs using the Karatsuba multiplication algorithm. It is loosely based on the description from Knuth [1, pp. 294-295] (Figure 5.8). To split the two inputs into their respective halves, a suitable radix point must be chosen. The radix point chosen must be used for both of the inputs, meaning
112
www.syngress.com
that it must be smaller than the smallest input. Step 3 chooses the radix point B as half of the smallest input used count. After the radix point is chosen, the inputs are split into lower and upper halves. Steps 4 and 5 compute the lower halves. Steps 6 and 7 compute the upper halves. After the halves have been computed the three intermediate half-size products must be computed. Step 8 and 9 compute the trivial products x0 · y0 and x1 · y1. The mp int x0 is used as a temporary variable after x1 + x0 has been computed. By using x0 instead of an additional temporary variable, the algorithm can avoid an addition memory allocation operation. The remaining steps 13 through 18 compute the Karatsuba polynomial through a variety of digit shifting and addition operations. File: bn mp karatsuba mul.c 018 /* c = |a| * |b| using Karatsuba Multiplication using 019 * three half size multiplications 020 * 021 * Let B represent the radix [e.g. 2**DIGIT_BIT] and 022 * let n represent half of the number of digits in 023 * the min(a,b) 024 * 025 * a = a1 * B**n + a0 026 * b = b1 * B**n + b0 027 * 028 * Then, a * b => 029 a1b1 * B**2n + ((a1 + a0)(b1 + b0) - (a0b0 + a1b1)) * B + a0b0 030 * 031 * Note that a1b1 and a0b0 are used twice and only need to be 032 * computed once. So in total three half size (half # of 033 * digit) multiplications are performed, a0b0, a1b1 and 034 * (a1+b1)(a0+b0) 035 * 036 * Note that a multiplication of half the digits requires 037 * 1/4th the number of single precision multiplications so in 038 * total after one call 25% of the single precision multiplications 039 * are saved. Note also that the call to mp_mul can end up back 040 * in this function if the a0, a1, b0, or b1 are above the threshold. 041 * This is known as divide-and-conquer and leads to the famous 042 * O(N**lg(3)) or O(N**1.584) work which is asymptopically lower than 043 * the standard O(N**2) that the baseline/comba methods use. 044 * Generally though the overhead of this method doesn’t pay off 045 * until a certain size (N ~ 80) is reached.
113
5.2 Multiplication 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074 075 076 077 078 079 080 081 082 083 084 085 086
*/ int mp_karatsuba_mul (mp_int * a, mp_int * b, mp_int * c) { mp_int x0, x1, y0, y1, t1, x0y0, x1y1; int B, err; /* default the return code to an error */ err = MP_MEM; /* min # of digits */ B = MIN (a->used, b->used); /* now divide in two */ B = B >> 1; /* init copy all if (mp_init_size goto ERR; if (mp_init_size goto X0; if (mp_init_size goto X1; if (mp_init_size goto Y0;
the temps */ (&x0, B) != MP_OKAY) (&x1, a->used - B) != MP_OKAY) (&y0, B) != MP_OKAY) (&y1, b->used - B) != MP_OKAY)
/* init temps */ if (mp_init_size (&t1, B * 2) != MP_OKAY) goto Y1; if (mp_init_size (&x0y0, B * 2) != MP_OKAY) goto T1; if (mp_init_size (&x1y1, B * 2) != MP_OKAY) goto X0Y0; /* now shift the digits */ x0.used = y0.used = B; x1.used = a->used - B; y1.used = b->used - B; { register int x; register mp_digit *tmpa, *tmpb, *tmpx, *tmpy;
114 087 088 089 090 091 092 093 094 095 096 097 098 099 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
www.syngress.com
/* we copy the digits directly instead of using higher level functions * since we also need to shift the digits */ tmpa = a->dp; tmpb = b->dp; tmpx = x0.dp; tmpy = y0.dp; for (x = 0; x < B; x++) { *tmpx++ = *tmpa++; *tmpy++ = *tmpb++; } tmpx = x1.dp; for (x = B; x < a->used; x++) { *tmpx++ = *tmpa++; } tmpy = y1.dp; for (x = B; x < b->used; x++) { *tmpy++ = *tmpb++; } } /* only need to clamp the lower words since by definition the * upper words x1/y1 must have a known number of digits */ mp_clamp (&x0); mp_clamp (&y0); /* now calc the products x0y0 and x1y1 */ /* after this x0 is no longer required, free temp [x0==t2]! */ if (mp_mul (&x0, &y0, &x0y0) != MP_OKAY) goto X1Y1; /* x0y0 = x0*y0 */ if (mp_mul (&x1, &y1, &x1y1) != MP_OKAY) goto X1Y1; /* x1y1 = x1*y1 */ /* now calc x1+x0 and y1+y0 */ if (s_mp_add (&x1, &x0, &t1) != MP_OKAY) goto X1Y1; /* t1 = x1 - x0 */
5.2 Multiplication 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
115
if (s_mp_add (&y1, &y0, &x0) != MP_OKAY) goto X1Y1; /* t2 = y1 - y0 */ if (mp_mul (&t1, &x0, &t1) != MP_OKAY) goto X1Y1; /* t1 = (x1 + x0) * (y1 + y0) */ /* add x0y0 */ if (mp_add (&x0y0, &x1y1, &x0) != MP_OKAY) goto X1Y1; /* t2 = x0y0 + x1y1 */ if (s_mp_sub (&t1, &x0, &t1) != MP_OKAY) goto X1Y1; /* t1 = (x1+x0)*(y1+y0) - (x1y1 + x0y0) */ /* shift by B */ if (mp_lshd (&t1, B) != MP_OKAY) goto X1Y1; /* t1 = (x0y0 + x1y1 - (x1-x0)*(y1-y0))sign == b->sign) ? MP_ZPOS : MP_NEG; /* use Toom-Cook? */ #ifdef BN_MP_TOOM_MUL_C if (MIN (a->used, b->used) >= TOOM_MUL_CUTOFF) { res = mp_toom_mul(a, b, c); } else #endif #ifdef BN_MP_KARATSUBA_MUL_C /* use Karatsuba? */ if (MIN (a->used, b->used) >= KARATSUBA_MUL_CUTOFF) { res = mp_karatsuba_mul (a, b, c); } else #endif { /* can we use the fast multiplier? * * The fast multiplier can be used if the output will * have less than MP_WARRAY digits and the number of * digits won’t affect carry propagation */ int digs = a->used + b->used + 1; #ifdef BN_FAST_S_MP_MUL_DIGS_C if ((digs < MP_WARRAY) && MIN(a->used, b->used) used > 0) ? neg : MP_ZPOS; return res; }
The implementation is rather simplistic and is not particularly noteworthy. Line 22 computes the sign of the result using the “?” operator from the C programming language. Line 48 computes δ using the fact that 1 0 do 4.5.1 iy ← iy + 1 4.5.2 rˆ ← tix+iy + u 4.5.3 tix+iy ← rˆ (mod β) 4.5.4 u ← ⌊ˆ r /β⌋ 5. Clamp excess digits of t. (mp clamp) 6. Exchange b and t. 7. Clear t (mp clear ) 8. Return(MP OKAY )
Figure 5.12: Algorithm s mp sqr Algorithm s mp sqr. This algorithm computes the square of an input using the three observations on squaring. It is based fairly faithfully on algorithm 14.16 of HAC [2, pp.596-597]. Similar to algorithm s mp mul digs, a temporary mp int is allocated to hold the result of the squaring. This allows the destination mp int to be the same as the source mp int (Figure 5.12). The outer loop of this algorithm begins on step 4. It is best to think of the outer loop as walking down the rows of the partial results, while the inner loop computes the columns of the partial result. Steps 4.1 and 4.2 compute the square term for each row, and steps 4.3 and 4.4 propagate the carry and compute the
5.3 Squaring
131
double products. The requirement that an mp word be able to represent the range 0 ≤ x < 2β 2 arises from this very algorithm. The product aix aiy will lie in the range 0 ≤ x ≤ β 2 − 2β + 1, which is obviously less than β 2 , meaning that when it is multiplied by two, it can be properly represented by an mp word. Similar to algorithm s mp mul digs, after every pass of the inner loop, the destination is correctly set to the sum of all of the partial results calculated so far. This involves expensive carry propagation, which will be eliminated in the next algorithm. File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047
bn s mp sqr.c /* low level squaring, b = a*a, HAC pp.596-597, Algorithm 14.16 */ int s_mp_sqr (mp_int * a, mp_int * b) { mp_int t; int res, ix, iy, pa; mp_word r; mp_digit u, tmpx, *tmpt; pa = a->used; if ((res = mp_init_size (&t, 2*pa + 1)) != MP_OKAY) { return res; } /* default used is maximum possible size */ t.used = 2*pa + 1; for (ix = 0; ix < pa; ix++) { /* first calculate the digit at 2*ix */ /* calculate double precision result */ r = ((mp_word) t.dp[2*ix]) + ((mp_word)a->dp[ix])*((mp_word)a->dp[ix]); /* store lower part in result */ t.dp[ix+ix] = (mp_digit) (r & ((mp_word) MP_MASK)); /* get the carry */ u = (mp_digit)(r >> ((mp_word) DIGIT_BIT)); /* left hand side of A[ix] * A[iy] */ tmpx = a->dp[ix];
132 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074 075 076 077 078 079 080
www.syngress.com
/* alias for where to store the results */ tmpt = t.dp + (2*ix + 1); for (iy = ix + 1; iy < pa; iy++) { /* first calculate the product */ r = ((mp_word)tmpx) * ((mp_word)a->dp[iy]); /* now calculate the double precision result, note we use * addition instead of *2 since it’s easier to optimize */ r = ((mp_word) *tmpt) + r + r + ((mp_word) u); /* store lower part */ *tmpt++ = (mp_digit) (r & ((mp_word) MP_MASK)); /* get carry */ u = (mp_digit)(r >> ((mp_word) DIGIT_BIT)); } /* propagate upwards */ while (u != ((mp_digit) 0)) { r = ((mp_word) *tmpt) + ((mp_word) u); *tmpt++ = (mp_digit) (r & ((mp_word) MP_MASK)); u = (mp_digit)(r >> ((mp_word) DIGIT_BIT)); } } mp_clamp (&t); mp_exch (&t, b); mp_clear (&t); return MP_OKAY; }
Inside the outer loop (line 34) the square term is calculated on line 37. The carry (line 44) has been extracted from the mp word accumulator using a right shift. Aliases for aix and tix+iy are initialized (lines 47 and 50) to simplify the inner loop. The doubling is performed using two additions (line 59), since it is usually faster than shifting, if not at least as fast. The important observation is that the inner loop does not begin at iy = 0 like for multiplication. As such, the inner loops get progressively shorter as the
5.3 Squaring
133
algorithm proceeds. This is what leads to the savings compared to using a multiplication to square a number.
5.3.2
Faster Squaring by the “Comba” Method
A major drawback to the baseline method is the requirement for single precision shifting inside the O(n2 ) nested loop. Squaring has an additional drawback in that it must double the product inside the inner loop as well. As for multiplication, the Comba technique can be used to eliminate these performance hazards. The first obvious solution is to make an array of mp words that will hold all the columns. This will indeed eliminate all of the carry propagation operations from the inner loop. However, the inner product must still be doubled O(n2 ) times. The solution stems from the simple fact that 2a + 2b + 2c = 2(a + b + c). That is, the sum of all of the double products is equal to double the sum of all the products. For example, ab + ba + ac + ca = 2ab + 2ac = 2(ab + ac). However, we cannot simply double all the columns, since the squares appear only once per row. The most practical solution is to have two mp word arrays. One array will hold the squares, and the other will hold the double products. With both arrays, the doubling and carry propagation can be moved to a O(n) work level outside the O(n2 ) level. In this case, we have an even simpler solution in mind.
134
www.syngress.com Algorithm fast s mp sqr. Input. mp int a Output. b ← a2 Place an array of MP WARRAY mp digits named W on the stack. 1. If b.alloc < 2a.used + 1 then grow b to 2a.used + 1 digits. (mp grow ). 2. If step 1 failed return(MP MEM ). 3. 4. 5.
pa ← 2 · a.used ˆ1←0 W for ix from 0 to pa − 1 do ˆ ←0 5.1 W 5.2 ty ← MIN(a.used − 1, ix) 5.3 tx ← ix − ty 5.4 iy ← MIN(a.used − tx, ty + 1) 5.5 iy ← MIN(iy, ⌊(ty − tx + 1) /2⌋) 5.6 for iz from 0 to iz − 1 do ˆ ← W ˆ + atx+iz aty−iz 5.6.1 W ˆ ←2· W ˆ +W ˆ1 5.7 W 5.8 if ix is even then ´ ` ˆ ← W ˆ + a⌊ix/2⌋ 2 5.8.1 W ˆ (mod β) 5.9 Wix ← W ˆ /β⌋ ˆ 5.10 W 1 ← ⌊ W
6. oldused ← b.used 7. b.used ← 2 · a.used 8. for ix from 0 to pa − 1 do 8.1 bix ← Wix 9. for ix from pa to oldused − 1 do 9.1 bix ← 0 10. Clamp excess digits from b. (mp clamp) 11. Return(MP OKAY ).
Figure 5.13: Algorithm fast s mp sqr Algorithm fast s mp sqr. This algorithm computes the square of an input using the Comba technique. It is designed to be a replacement for algorithm s mp sqr when the number of input digits is less than MP WARRAY and less than 2δ . This algorithm is very similar to the Comba multiplier, except with a few
5.3 Squaring
135
key differences we shall make note of (Figure 5.13). ˆ and W ˆ 1, respectively. First, we have an accumulator and carry variables W This is because the inner loop products are to be doubled. If we had added the previous carry in we would be doubling too much. Next, we perform an addition MIN condition on iy (step 5.5) to prevent overlapping digits. For example, a3 · a5 is equal a5 · a3 , whereas in the multiplication case we would have 5 < a.used, and 3 ≥ 0 is maintained since we double the sum of the products just outside the inner loop, which we have to avoid doing. This is also a good thing since we perform fewer multiplications and the routine ends up being faster. The last difference is the addition of the “square” term outside the inner loop (step 5.8). We add in the square only to even outputs, and it is the square of the term at the ⌊ix/2⌋ position. File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043
bn /* * * * * *
fast s mp sqr.c the gist of squaring... you do like mult except the offset of the tmpx [one that starts closer to zero] can’t equal the offset of tmpy. So basically you set up iy like before then you min it with (ty-tx) so that it never happens. You double all those you add in the inner loop
After that loop you do the squares and add them in. */ int fast_s_mp_sqr (mp_int * a, mp_int * b) { int olduse, res, pa, ix, iz; mp_digit W[MP_WARRAY], *tmpx; mp_word W1; /* grow the destination as required */ pa = a->used + a->used; if (b->alloc < pa) { if ((res = mp_grow (b, pa)) != MP_OKAY) { return res; } } /* number of output digits to produce */ W1 = 0;
136 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074 075 076 077 078 079 080 081 082 083 084
www.syngress.com for (ix = 0; int mp_word mp_digit
ix < pa; ix++) { tx, ty, iy; _W; *tmpy;
/* clear counter */ _W = 0; /* get offsets into the two bignums */ ty = MIN(a->used-1, ix); tx = ix - ty; /* setup temp aliases */ tmpx = a->dp + tx; tmpy = a->dp + ty; /* this is the number of times the loop will iterate, essentially while (tx++ < a->used && ty-- >= 0) { ... } */ iy = MIN(a->used-tx, ty+1); /* now for squaring tx can never equal ty * we halve the distance since they approach at a rate of 2x * and we have to round because odd cases need to be executed */ iy = MIN(iy, (ty-tx+1)>>1); /* execute loop */ for (iz = 0; iz < iy; iz++) { _W += ((mp_word)*tmpx++)*((mp_word)*tmpy--); } /* double the inner product and add carry */ _W = _W + _W + W1; /* even columns have the square term in them */ if ((ix&1) == 0) { _W += ((mp_word)a->dp[ix>>1])*((mp_word)a->dp[ix>>1]); } /* store it */
5.3 Squaring 085 086 087 088 089 090 091 092 093 094 095 096 097 098 099 100 101 102 103 104 105 106 107 108 109 110
137
W[ix] = (mp_digit)(_W & MP_MASK); /* make next carry */ W1 = _W >> ((mp_word)DIGIT_BIT); } /* setup dest */ olduse = b->used; b->used = a->used+a->used; { mp_digit *tmpb; tmpb = b->dp; for (ix = 0; ix < pa; ix++) { *tmpb++ = W[ix] & MP_MASK; } /* clear unused digits [that existed in the old copy of c] */ for (; ix < olduse; ix++) { *tmpb++ = 0; } } mp_clamp (b); return MP_OKAY; }
This implementation is essentially a copy of Comba multiplication with the appropriate changes added to make it faster for the special case of squaring. The innermost loop (lines 72 to 74) computes the products the same way the multiplication routine does. The sum of the products is doubled separately (line 77) outside the innermost loop. The square term is added if ix is even (lines 80 to 82), indicating column with a square.
5.3.3
Even Faster Squaring
Just like the case of algorithm fast mult (Section 5.2.3), squaring can be performed using the full precision of single precision variables. This algorithm borrows much from the algorithm in Figure 5.13. Except that, in this case, we will be accumulating into a triple–precision accumulator. Similarly, loop unrolling can boost the
138
www.syngress.com
performance of this operation significantly. The TomsFastMath library incorporates fast squaring that is a direct port of algorithm fast s mp sqr. Readers are encouraged to research this project to learn more.
5.3.4
Polynomial Basis Squaring
The same algorithm that performs optimal polynomial basis multiplication can be used to perform polynomial basis squaring. The minor exception is that ζy = f (y)g(y) is actually equivalent to ζy = f (y)2 , since f (y) = g(y). Instead of performing 2n + 1 multiplications to find the ζ relations, squaring operations are performed instead.
5.3.5
Karatsuba Squaring
Let f (x) = ax + b represent the polynomial basis representation of a number to 2 square. Let h(x) = (f (x)) represent the square of the polynomial. The Karatsuba equation can be modified to square a number with the following equation. h(x) = a2 x2 + (a + b)2 − (a2 + b2 ) x + b2
(5.7)
Upon closer inspection, this equation only requires the calculation of three half-sized squares: a2 , b2 , and (a + b)2 . As in Karatsuba multiplication, this algorithm can be appliedrecursively on the input and will achieve an asymptotic running time of O nlg(3) . If the asymptotic times of Karatsuba squaring and multiplication are the same, why not simply use the multiplication algorithm instead? The answer to this arises from the cutoff point for squaring. As in multiplication, there exists a cutoff point, at which the time required for a Comba–based squaring and a Karatsuba–based squaring meet. Due to the overhead inherent in the Karatsuba method, the cutoff point is fairly high. For example, on an AMD Athlon XP processor with β = 228 , the cutoff point is around 127 digits. Consider squaring a 200–digit number with this technique. It will be split into two 100–digit halves that are subsequently squared. The 100–digit halves will not be squared using Karatsuba, but instead using the faster Comba–based squaring algorithm. If Karatsuba multiplication were used instead, the 100–digit numbers would be squared with a slower Comba–based multiplication.
139
5.3 Squaring Algorithm mp karatsuba sqr. Input. mp int a Output. b ← a2 1. Initialize the following temporary mp ints: x0, x1, t1, t2, x0x0, and x1x1. 2. If any of the initializations on step 1 failed return(MP MEM ). Split the input. e.g. a = x1β B + x0 3. B ← ⌊a.used/2⌋ 4. x0 ← a (mod β B ) (mp mod 2d ) 5. x1 ← ⌊a/β B ⌋ (mp lshd ) Calculate the three squares. 6. x0x0 ← x02 (mp sqr ) 7. x1x1 ← x12 8. t1 ← x1 + x0 (s mp add ) 9. t1 ← t12 Compute the middle term. 10. t2 ← x0x0 + x1x1 (s mp add ) 11. t1 ← t1 − t2 Compute final product. 12. t1 ← t1β B (mp lshd ) 13. x1x1 ← x1x1β 2B 14. t1 ← t1 + x0x0 15. b ← t1 + x1x1 16. Return(MP OKAY ).
Figure 5.14: Algorithm mp karatsuba sqr Algorithm mp karatsuba sqr. This algorithm computes the square of an input a using the Karatsuba technique. It is very similar to the Karatsuba–based multiplication algorithm with the exception that the three half-size multiplications have been replaced with three half-size squarings (Figure 5.14). The radix point for squaring is simply placed exactly in the middle of the digits when the input has an odd number of digits; otherwise, it is placed just below the middle. Steps 3, 4, and 5 compute the two halves required using B as the radix point. The first two squares in steps 6 and 7 are straightforward, while the last
140
www.syngress.com
square is of a more compact form. By expanding (x1 + x0)2 , the x12 and x02 terms in the middle disappear; that is, (x0 − x1)2 − (x12 + x02 ) = 2 · x0 · x1. Now if 5n single precision additions and a squaring of n-digits is faster than multiplying two n-digit numbers and doubling, then this method is faster. Assuming no further recursions occur, the difference can be estimated with the following inequality. Let p represent the cost of a single precision addition and q the cost of a single precision multiplication both in terms of time4 . 5pn +
q(n2 + n) ≤ pn + qn2 2
For example, on an AMD Athlon XP processor, p = that the following inequality should hold. 5n 3
+ 3n2 + 3n 5 3 + 3n + 3 13 9
< <
used; /* now divide in two */ B = B >> 1; /* init copy all the temps */ if (mp_init_size (&x0, B) != MP_OKAY) goto ERR; if (mp_init_size (&x1, a->used - B) != MP_OKAY) goto X0; /* init temps */ if (mp_init_size goto X1; if (mp_init_size goto T1; if (mp_init_size goto T2; if (mp_init_size goto X0X0;
(&t1, a->used * 2) != MP_OKAY) (&t2, a->used * 2) != MP_OKAY) (&x0x0, B * 2) != MP_OKAY) (&x1x1, (a->used - B) * 2) != MP_OKAY)
{ register int x; register mp_digit *dst, *src; src = a->dp; /* now shift the digits */ dst = x0.dp; for (x = 0; x < B; x++) { *dst++ = *src++; } dst = x1.dp; for (x = B; x < a->used; x++) { *dst++ = *src++; } }
142 072 073 074 075 076 077 078 079 080 081 082 083 084 085 086 087 088 089 090 091 092 093 094 095 096 097 098 099 100 101 102 103 104 105 106 107 108 109 110 111 112
www.syngress.com x0.used = B; x1.used = a->used - B; mp_clamp (&x0); /* now calc the products x0*x0 and x1*x1 */ if (mp_sqr (&x0, &x0x0) != MP_OKAY) goto X1X1; /* x0x0 = x0*x0 */ if (mp_sqr (&x1, &x1x1) != MP_OKAY) goto X1X1; /* x1x1 = x1*x1 */ /* now calc (x1+x0)**2 */ if (s_mp_add (&x1, &x0, &t1) != MP_OKAY) goto X1X1; /* t1 = x1 - x0 */ if (mp_sqr (&t1, &t1) != MP_OKAY) goto X1X1; /* t1 = (x1 - x0) * (x1 - x0) */ /* add x0y0 */ if (s_mp_add (&x0x0, &x1x1, &t2) != MP_OKAY) goto X1X1; /* t2 = x0x0 + x1x1 */ if (s_mp_sub (&t1, &t2, &t1) != MP_OKAY) goto X1X1; /* t1 = (x1+x0)**2 - (x0x0 + x1x1) */ /* shift by B */ if (mp_lshd (&t1, B) != MP_OKAY) goto X1X1; /* t1 = (x0x0 + x1x1 - (x1-x0)*(x1-x0))used >= KARATSUBA_SQR_CUTOFF) { res = mp_karatsuba_sqr (a, b); } else #endif { #ifdef BN_FAST_S_MP_SQR_C /* can we use the fast comba multiplier? */ if ((a->used * 2 + 1) < MP_WARRAY && a->used < (1 sign = MP_ZPOS; return res; }
145
146
www.syngress.com
Exercises [3]
Devise an efficient algorithm for selection of the radix point to handle inputs that have different numbers of digits in Karatsuba multiplication.
[2]
In section 5.3, we stated, that every column of a squaring is made up of double products and at most one square is stated. Prove this statement.
[3]
Prove the equation for Karatsuba squaring.
[1]
Prove that Karatsuba squaring requires O nlg(3) time.
[3]
Implement a threaded version of Comba multiplication (and squaring) where you compute subsets of the columns in each thread. Determine a cutoff point where it is effective, and add the logic to mp mul() and mp sqr().
[4]
Same as the previous, but also modify the Karatsuba and Toom-Cook. You must increase the throughput of mp exptmod() for random odd moduli in the range 512 . . . 4096 bits significantly (> 2x) to complete this challenge.
Chapter 6
Modular Reduction 6.1
Basics of Modular Reduction
Modular reduction arises quite often within public key cryptography algorithms and various number theoretic algorithms, such as factoring. Modular reduction algorithms are the third class of algorithms of the “multipliers” set. A number a is said to be reduced modulo another number b by finding the remainder of the division a/b. Full integer division with remainder is covered in Section 8.1. Modular reduction is equivalent to solving for r in the following equation: a = bq + r where q = ⌊a/b⌋. The result r is said to be “congruent to a modulo b,” which is also written as r ≡ a (mod b). In other vernacular, r is known as the “modular residue,” which leads to “quadratic residue”1 and other forms of residues. Modular reductions are normally used to create finite groups, rings, or fields. The most common usage for performance driven modular reductions is in modular exponentiation algorithms; that is, to compute d = ab (mod c) as fast as possible. This operation is used in the RSA and Diffie-Hellman public key algorithms, for example. Modular multiplication and squaring also appears as a fundamental operation in elliptic curve cryptographic algorithms. As will be discussed in the subsequent chapter, there exist fast algorithms for computing modular exponentiations without having to perform (in this example) b − 1 multiplications. These algorithms will produce partial results in the range 0 ≤ x < c2 , which can be taken 1 That’s
fancy talk for b ≡ a2 (mod p).
147
148
www.syngress.com
advantage of to create several efficient algorithms. They have also been used to create redundancy check algorithms known as CRCs, error correction codes such as Reed-Solomon, and solve a variety of number theoretic problems.
6.2
The Barrett Reduction
The Barrett reduction algorithm [6] was inspired by fast division algorithms that multiply by the reciprocal to emulate division. Barrett’s observation was that the residue c of a modulo b is equal to c = a − b · ⌊a/b⌋
(6.1)
Since algorithms such as modular exponentiation would be using the same modulus extensively, typical DSP2 intuition would indicate the next step would be to replace a/b by a multiplication by the reciprocal. However, DSP intuition on its own will not work, as these numbers are considerably larger than the precision of common DSP floating point data types. It would take another common optimization to optimize the algorithm.
6.2.1
Fixed Point Arithmetic
The trick used to optimize equation 6.1 is based on a technique of emulating floating point data types with fixed precision integers. Fixed point arithmetic would become very popular, as it greatly optimized the “3D–shooter” genre of games in the mid 1990s when floating point units were fairly slow, if not unavailable. The idea behind fixed point arithmetic is to take a normal k-bit integer data type and break it into p-bit integer and a q-bit fraction part (where p + q = k). In this system, a k-bit integer n would actually represent n/2q . For example, with q = 4 the integer n = 37 would actually represent the value 2.3125. To multiply two fixed point numbers, the integers are multiplied using traditional arithmetic and subsequently normalized by moving the implied decimal point back to where it should be. For example, with q = 4, to multiply the integers 9 and 5 they must be converted to fixed point first by multiplying by 2q . Let a = 9(2q ) represent the fixed point representation of 9, and b = 5(2q ) represent the fixed point representation of 5. The product ab is equal to 45(22q ), which when normalized by dividing by 2q produces 45(2q ). 2 It
is worth noting that Barrett’s paper targeted the DSP56K processor.
149
6.2 The Barrett Reduction
This technique became popular since a normal integer multiplication and logical shift right are the only required operations to perform a multiplication of two fixed point numbers. Using fixed point arithmetic, division can be easily approximated by multiplying by the reciprocal. If 2q is equivalent to one, then, 2q /b is equivalent to the fixed point approximation of 1/b using real arithmetic. Using this fact, dividing an integer a by another integer b can be achieved with the following expression. ⌊a/b⌋ ∼ ⌊(a · ⌊2q /b⌋)/2q ⌋
(6.2)
The precision of the division is proportional to the value of q. If the divisor b is used frequently, as is the case with modular exponentiation, pre-computing 2q /b will allow a division to be performed with a multiplication and a right shift. Both operations are considerably faster than division on most processors. Consider dividing 19 by 5. The correct result is ⌊19/5⌋ = 3. With q = 3, the reciprocal is ⌊2q /5⌋ = 1, which leads to a product of 19, which when divided by 2q produces 2. However, with q = 4 the reciprocal is ⌊2q /5⌋ = 3 and the result of the emulated division is ⌊3 · 19/2q ⌋ = 3, which is correct. The value of 2q must be close to or ideally larger than the dividend. In effect, if a is the dividend, then q should allow 0 ≤ ⌊a/2q ⌋ ≤ 1 for this approach to work correctly. Plugging this form of division into the original equation, the following modular residue equation arises. c = a − b · ⌊(a · ⌊2q /b⌋)/2q ⌋
(6.3)
q
Using the notation from [6], the value of ⌊2 /b⌋ will be represented by the µ symbol. Using the µ variable also helps reinforce the idea that it is meant to be computed once and re-used. c = a − b · ⌊(a · µ)/2q ⌋ q
(6.4)
Provided that 2 ≥ a, this algorithm will produce a quotient that is either exactly correct or off by a value of one. In the context of Barrett reduction the value of a is bound by 0 ≤ a ≤ (b − 1)2 , meaning that 2q ≥ b2 is sufficient to ensure the reciprocal will have enough precision. Let n represent the number of digits in b. This algorithm requires approximately 2n2 single precision multiplications to produce the quotient, and another n2 single precision multiplications to find the residue. In total, 3n2 single precision multiplications are required to reduce the number.
150
www.syngress.com
For example, if b = 1179677 and q = 41 (2q > b2 ), the reciprocal µ is equal to ⌊2q /b⌋ = 1864089. Consider reducing a = 180388626447 modulo b using the preceding reduction equation. The quotient using the new formula is ⌊(a·µ)/2q ⌋ = 152913. By subtracting 152913b from a, the correct residue a ≡ 677346 (mod b) is found.
6.2.2
Choosing a Radix Point
Using the fixed point representation, a modular reduction can be performed with 3n2 single precision multiplications3 . If that were the best that could be achieved. a full division4 might as well be used in its place. The key to optimizing the reduction is to reduce the precision of the initial multiplication that finds the quotient. Let a represent the number of which the residue is sought. Let b represent the modulus used to find the residue. Let m represent the number of digits in b. For the purposes of this discussion we will assume that the number of digits in a is 2m, which is generally true if two m-digit numbers have been multiplied. Dividing a by b is the same as dividing a 2m digit integer by an m digit integer. Digits below the m − 1’th digit of a will contribute at most a value of 1 to the quotient, because β k < b for any 0 ≤ k ≤ m − 1. Another way to express this is ′ ′′ , by re-writing a as two parts. If a′ ≡ a (mod bm ) and a′′ = a − a′ , then ab ≡ a +a b a′ a′′ ′ which is equivalent to b + b . Since a is bound to be less than b, the quotient is ′ bound by 0 ≤ ab < 1. Since the digits of a′ do not contribute much to the quotient the observation is that they might as well be zero. However, if the digits “might as well be zero,” they might as well not be there in the first place. Let q0 = ⌊a/β m−1 ⌋ represent the input with the irrelevant digits trimmed. Now the modular reduction is trimmed to the almost equivalent equation c = a − b · ⌊(q0 · µ)/β m+1 ⌋
(6.5)
Note that the original divisor 2q has been replaced with β m+1 where in this case q is a multiple of lg(β). Also note that the exponent on the divisor when added to the amount q0 was shifted by equals 2m. If the optimization had not been performed the divisor would have the exponent 2m, so in the end the exponents 3 One
division and two multiplications require 3n2 single precision multiplications. division requires approximately O(2cn2 ) single precision multiplications for a small value of c. See 8.1 for further details. 4A
6.2 The Barrett Reduction
151
do “add up.” Using equation 6.5 the quotient ⌊(q0 · µ)/β m+1 ⌋ can be off from the true quotient by at most two. The original fixed point quotient can be off by as much as one (provided the radix point is chosen suitably), and now that the lower irrelevant digits have been trimmed the quotient can be off by an additional value of one for a total of at most two. This implies that 0 ≤ a − b · ⌊(q0 · µ)/β m+1 ⌋ < 3b. By first subtracting b times the quotient and then conditionally subtracting b once or twice the residue is found. The quotient is now found using (m + 1)(m) = m2 + m single precision multiplications and the residue with an additional m2 single precision multiplications, ignoring the subtractions required. In total, 2m2 + m single precision multiplications are required to find the residue. This is considerably faster than the original attempt. For example, let β = 10 represent the radix of the digits. Let b = 9999 represent the modulus, which implies m = 4. Let a = 99929878 represent the value of which the residue is desired; in this case, q = 8 since 107 < 99992, meaning that µ = ⌊β q /b⌋ = 10001. With the new observation the multiplicand for the quotient is equal to q0 = ⌊a/β m−1 ⌋ = 99929. The quotient is then ⌊(q0 · µ)/β m+1 ⌋ = 9993. Subtract 9993b from a and the correct residue a ≡ 9871 (mod b) is found.
6.2.3
Trimming the Quotient
So far, the reduction algorithm has been optimized from 3m2 single precision multiplications down to 2m2 +m single precision multiplications. As it stands now, the algorithm is already fairly fast compared to a full integer division algorithm. However, there is still room for optimization. After the first multiplication inside the quotient (q0 · µ) the value is shifted right by m + 1 places, effectively nullifying the lower half of the product. It would be nice to be able to remove those digits from the product to effectively cut down the number of single precision multiplications. If the number of digits in the modulus m is far less than β, a full product is not required for the algorithm to work properly. In fact, the lower m − 2 digits will not affect the upper half of the product at all and do not need to be computed. The value of µ is an m-digit number and q0 is an m + 1 digit number. Using a full multiplier (m + 1)(m) = m2 + m single precision multiplications would be required. Using a multiplier that will only produce digits at and above the 2 m − 1’th digit reduces the number of single precision multiplications to m 2+m single precision multiplications.
152
6.2.4
www.syngress.com
Trimming the Residue
After the quotient has been calculated it is used to reduce the input. As previously noted, the algorithm is not exact and can be off by a small multiple of the modulus; that is, 0 ≤ a − b · ⌊(q0 · µ)/β m+1 ⌋ < 3b. If b is m digits, the result of reduction equation is a value of at most m + 1 digits (provided 3 < β) implying that the upper m − 1 digits are implicitly zero. The next optimization arises from this very fact. Instead of computing b · ⌊(q0 · µ)/β m+1 ⌋ using a full O(m2 ) multiplication algorithm, only the lower m + 1 digits of the product have to be computed. Similarly, the value of a can be reduced modulo β m+1 before the multiple of b is subtracted, which simplifies the subtraction as well. A multiplication that produces only the lower m + 1 digits 2 single precision multiplications. requires m +3m−2 2 With both optimizations in place the algorithm is the algorithm Barrett proposed. It requires m2 + 2m − 1 single precision multiplications, which are considerably faster than the straightforward 3m2 method.
6.2 The Barrett Reduction
6.2.5
153
The Barrett Algorithm
Algorithm mp reduce. Input. mp int a, mp int b and µ = ⌊β 2m /b⌋, m = ⌈lgβ (b)⌉, (0 ≤ a < b2 , b > 1) Output. a (mod b) Let m represent the number of digits in b. 1. Make a copy of a and store it in q. (mp init copy) 2. q ← ⌊q/β m−1 ⌋ (mp rshd ) Produce the quotient. 3. q ← q · µ (note: only produce digits at or above m − 1) 4. q ← ⌊q/β m+1 ⌋ Subtract the multiple of modulus from the input. 5. a ← a (mod β m+1 ) (mp mod 2d ) 6. q ← q · b (mod β m+1 ) (s mp mul digs) 7. a ← a − q (mp sub) Add β m+1 if a carry occurred. 8. If a < 0 then (mp cmp d ) 8.1 q ← 1 (mp set) 8.2 q ← q · β m+1 (mp lshd ) 8.3 a ← a + q Now subtract the modulus if the residue is too large (e.g., quotient too small). 9. While a ≥ b do (mp cmp) 9.1 c ← a − b 10. Clear q. 11. Return(MP OKAY )
Figure 6.1: Algorithm mp reduce Algorithm mp reduce. This algorithm will reduce the input a modulo b in place using the Barrett algorithm. It is loosely based on algorithm 14.42 of HAC [2, pp. 602], which is based on the paper from Paul Barrett [6]. The algorithm has several restrictions and assumptions that must be adhered to for the algorithm to work (Figure 6.1). First, the modulus b is assumed positive and greater than one. If the modulus
154
www.syngress.com
were less than or equal to one, subtracting a multiple of it would either accomplish nothing or actually enlarge the input. The input a must be in the range 0 ≤ a < b2 for the quotient to have enough precision. If a is the product of two numbers that were already reduced modulo b, this will not be a problem. Technically, the algorithm will still work if a ≥ b2 but it will take much longer to finish. The value of µ is passed as an argument to this algorithm and is assumed calculated and stored before the algorithm is used. Recall that the multiplication for the quotient in step 3 must only produce digits at or above the m − 1’th position. An algorithm called s mp mul high digs that has not been presented is used to accomplish this task. The algorithm is based on s mp mul digs, except that instead of stopping at a given level of precision it starts at a given level of precision. This optimal algorithm can only be used if the number of digits in b is much smaller than β. While it is known that a ≥ b · ⌊(q0 · µ)/β m+1 ⌋, only the lower m + 1 digits are being used to compute the residue, so an implied “borrow” from the higher digits might leave a negative result. After the multiple of the modulus has been subtracted from a, the residue must be fixed up in case it is negative. The invariant β m+1 must be added to the residue to make it positive again. The while loop in step 9 will subtract b until the residue is less than b. If the algorithm is performed correctly, this step is performed at most twice, and on average once. However, if a ≥ b2 , it will iterate substantially more times than it should. File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033
bn mp reduce.c /* reduces x mod m, assumes 0 < x < m**2, mu is * precomputed via mp_reduce_setup. * From HAC pp.604 Algorithm 14.42 */ int mp_reduce (mp_int * x, mp_int * m, mp_int * mu) { mp_int q; int res, um = m->used; /* q = x */ if ((res = mp_init_copy (&q, x)) != MP_OKAY) { return res; } /* q1 = x / b**(k-1) */ mp_rshd (&q, um - 1);
6.2 The Barrett Reduction 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074
155
/* according to HAC this optimization is ok */ if (((unsigned long) um) > (((mp_digit)1) 1) Output. µ ← ⌊β 2m /a⌋ 1. µ ← 22·lg(β)·m (mp 2expt) 2. µ ← ⌊µ/b⌋ (mp div ) 3. Return(MP OKAY )
Figure 6.2: Algorithm mp reduce setup Algorithm mp reduce setup. This algorithm computes the reciprocal µ required for Barrett reduction. First, β 2m is calculated as 22·lg(β)·m , which is equivalent and much faster. The final value is computed by taking the integer quotient of ⌊µ/b⌋ (Figure 6.2). File: 018 019 020 021 022 023 024 025 026 027 028 029 030
bn mp reduce setup.c /* pre-calculate the value required for Barrett reduction * For a given modulus "b" it calculates the value required in "a" */ int mp_reduce_setup (mp_int * a, mp_int * b) { int res; if ((res = mp_2expt (a, b->used * 2 * DIGIT_BIT)) != MP_OKAY) { return res; } return mp_div (a, b, a, NULL); }
This simple routine calculates the reciprocal µ required by Barrett reduction. Note the extended usage of algorithm mp div where the variable that would receive the remainder is passed as NULL. As will be discussed in 8.1, the division routine allows both the quotient and the remainder to be passed as NULL, meaning to ignore the value.
158
6.3
www.syngress.com
The Montgomery Reduction
Montgomery reduction5 [7] is by far the most interesting form of reduction in common use. It computes a modular residue that is not actually equal to the residue of the input, yet instead equal to a residue times a constant. However, as perplexing as this may sound, the algorithm is relatively simple and very efficient. Throughout this entire section the variable n will represent the modulus used to form the residue. As will be discussed shortly, the value of n must be odd. The variable x will represent the quantity of which the residue is sought. Similar to the Barrett algorithm, the input is restricted to 0 ≤ x < n2 . To begin the description, some simple number theory facts must be established. Fact 1. Adding n to x does not change the residue, since in effect it adds one to the quotient ⌊x/n⌋. Another way to explain this is that n is (or multiples of n are) congruent to zero modulo n. Adding zero will not change the value of the residue. Fact 2. If x is even, then performing a division by two in Z is congruent to x · 2−1 (mod n). Actually, this is an application of the fact that if x is evenly divisible by any k ∈ Z, then division in Z will be congruent to multiplication by k −1 modulo n. From these two simple facts the following simple algorithm can be derived. Algorithm Montgomery Reduction. Input. Integer x, n and k Output. 2−k x (mod n) 1. for t from 1 to k do 1.1 If x is odd then 1.1.1 x ← x + n 1.2 x ← x/2 2. Return x.
Figure 6.3: Algorithm Montgomery Reduction The algorithm in Figure 6.3 reduces the input one bit at a time using the two congruencies stated previously. Inside the loop n, which is odd, is added to x if x is odd. This forces x to be even, which allows the division by two in Z to be congruent to a modular division by two. Since x is assumed initially much larger 5 Thanks
to Niels Ferguson for his insightful explanation of the algorithm.
159
6.3 The Montgomery Reduction
than n, the addition of n will contribute an insignificant magnitude to x. Let r represent the result of the Montgomery algorithm. If k > lg(n) and 0 ≤ x < n2 , then the result is limited to 0 ≤ r < ⌊x/2k ⌋ + n. At most, a single subtraction is required to get the residue desired. Step number (t) 1 2 3 4 5 6 7 8 9
Result (x) x + n = 5812, x/2 = 2906 x/2 = 1453 x + n = 1710, x/2 = 855 x + n = 1112, x/2 = 556 x/2 = 278 x/2 = 139 x + n = 396, x/2 = 198 x/2 = 99 x + n = 356, x/2 = 178
Figure 6.4: Example of Montgomery Reduction (I) Consider the example in Figure 6.4, which reduces x = 5555 modulo n = 257 when k = 9 (note β k = 512, which is larger than n). The result of the algorithm r = 178 is congruent to the value of 2−9 · 5555 (mod 257). When r is multiplied by 29 modulo 257, the correct residue r ≡ 158 is produced. Let k = ⌊lg(n)⌋ + 1 represent the number of bits in n. The current algorithm requires 2k 2 single precision shifts and k 2 single precision additions. At this rate, the algorithm is most certainly slower than Barrett reduction and not terribly useful. Fortunately, there exists an alternative representation of the algorithm. Algorithm Montgomery Reduction (modified I). Input. Integer x, n and k (2k > n) Output. 2−k x (mod n) 1. for t from 1 to k do 1.1 If the t’th bit of x is one then 1.1.1 x ← x + 2t n 2. Return x/2k .
Figure 6.5: Algorithm Montgomery Reduction (modified I)
160
www.syngress.com
This algorithm is equivalent since 2t n is a multiple of n and the lower k bits of x are zero by step 2. The number of single precision shifts has now been reduced from 2k 2 to k 2 + k, which is only a small improvement (Figure 6.5). Step number (t) – 1 2 3 4 5 6 7 8 9 –
Result (x) 5555 x + 20 n = 5812 5812 x + 22 n = 6840 x + 23 n = 8896 8896 8896 x + 26 n = 25344 25344 x + 27 n = 91136 x/2k = 178
Result (x) in Binary 1010110110011 1011010110100 1011010110100 1101010111000 10001011000000 10001011000000 10001011000000 110001100000000 110001100000000 10110010000000000
Figure 6.6: Example of Montgomery Reduction (II) Figure 6.6 demonstrates the modified algorithm reducing x = 5555 modulo n = 257 with k = 9. With this algorithm, a single shift right at the end is the only right shift required to reduce the input instead of k right shifts inside the loop. Note that for the iterations t = 2, 5, 6, and 8 where the result x is not changed. In those iterations the t’th bit of x is zero and the appropriate multiple of n does not need to be added to force the t’th bit of the result to zero.
6.3.1
Digit Based Montgomery Reduction
Instead of computing the reduction on a bit-by-bit basis it is much faster to compute it on digit-by-digit basis. Consider the previous algorithm re-written to compute the Montgomery reduction in this new fashion (Figure 6.7).
161
6.3 The Montgomery Reduction Algorithm Montgomery Reduction (modified II). Input. Integer x, n and k (β k > n) Output. β −k x (mod n) 1. for t from 0 to k − 1 do 1.1 x ← x + µnβ t 2. Return x/β k .
Figure 6.7: Algorithm Montgomery Reduction (modified II) The value µnβ t is a multiple of the modulus n, meaning that it will not change the residue. If the first digit of the value µnβ t equals the negative (modulo β) of the t’th digit of x, then the addition will result in a zero digit. This problem breaks down to solving the following congruency. xt + µn0 µn0 µ
≡ ≡ ≡
0 (mod β) −xt (mod β) −xt /n0 (mod β)
In each iteration of the loop in step 1 a new value of µ must be calculated. The value of −1/n0 (mod β) is used extensively in this algorithm and should be precomputed. Let ρ represent the negative of the modular inverse of n0 modulo β. For example, let β = 10 represent the radix. Let n = 17 represent the modulus, which implies k = 2 and ρ ≡ 7. Let x = 33 represent the value to reduce. The result in Figure 6.8 of 900 is then divided by β k to produce the result 9. The first observation is that 9 6≡ x (mod n), which implies the result is not the modular residue of x modulo n. However, recall that the residue is actually multiplied by β −k in the algorithm. To get the true residue the value must be Step (t) – 0 1
Value of x 33 33 + µn = 50 50 + µnβ = 900
Value of µ – 1 5
Figure 6.8: Example of Montgomery Reduction
162
www.syngress.com
multiplied by β k . In this case, β k ≡ 15 (mod n) and the correct residue is 9 · 15 ≡ 16 (mod n).
6.3.2
Baseline Montgomery Reduction
The baseline Montgomery reduction algorithm will produce the residue for any size input. It is designed to be a catch-all algorithm for Montgomery reductions.
6.3 The Montgomery Reduction
163
Algorithm mp montgomery reduce. Input. mp int x, mp int n and a digit ρ ≡ −1/n0 (mod n). (0 ≤ x < n2 , n > 1, (n, β) = 1, β k > n) Output. β −k x (mod n) 1. digs ← 2n.used + 1 2. If digs < M P ARRAY and m.used < δ then 2.1 Use algorithm fast mp montgomery reduce instead. Setup x for the reduction. 3. If x.alloc < digs then grow x to digs digits. 4. x.used ← digs Eliminate the lower k digits. 5. For ix from 0 to k − 1 do 5.1 µ ← xix · ρ (mod β) 5.2 u ← 0 5.3 For iy from 0 to k − 1 do 5.3.1 rˆ ← µniy + xix+iy + u 5.3.2 xix+iy ← rˆ (mod β) 5.3.3 u ← ⌊ˆ r /β⌋ 5.4 While u > 0 do 5.4.1 iy ← iy + 1 5.4.2 xix+iy ← xix+iy + u 5.4.3 u ← ⌊xix+iy /β⌋ 5.4.4 xix+iy ← xix+iy (mod β) Divide by β k and fix up as required. 6. x ← ⌊x/β k ⌋ 7. If x ≥ n then 7.1 x ← x − n 8. Return(MP OKAY ).
Figure 6.9: Algorithm mp montgomery reduce Algorithm mp montgomery reduce. This algorithm reduces the input x modulo n in place using the Montgomery reduction algorithm. The algorithm is loosely based on algorithm 14.32 of [2, pp.601], except it merges the multiplication of µnβ t with the addition in the inner loop. The restrictions on this algorithm are fairly easy to adapt to. First, 0 ≤ x < n2 bounds the input to numbers in the
164
www.syngress.com
same range as for the Barrett algorithm. Additionally, if n > 1 and n is odd there will exist a modular inverse ρ. ρ must be calculated in advance of this algorithm. Finally, the variable k is fixed and a pseudonym for n.used (Figure 6.9). Step 2 decides whether a faster Montgomery algorithm can be used. It is based on the Comba technique, meaning that there are limits on the size of the input. This algorithm is discussed in 7.9. Step 5 is the main reduction loop of the algorithm. The value of µ is calculated once per iteration in the outer loop. The inner loop calculates x + µnβ ix by multiplying µn and adding the result to x shifted by ix digits. Both the addition and multiplication are performed in the same loop to save time and memory. Step 5.4 will handle any additional carries that escape the inner loop. On quick inspection, this algorithm requires n single precision multiplications for the outer loop and n2 single precision multiplications in the inner loop for a total n2 + n single precision multiplications, which compares favorably to Barrett at n2 + 2n − 1 single precision multiplications. File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040
bn mp montgomery reduce.c /* computes xR**-1 (mod N) via Montgomery Reduction */ int mp_montgomery_reduce (mp_int * x, mp_int * n, mp_digit rho) { int ix, res, digs; mp_digit mu; /* can the fast reduction [comba] method be used? * * Note that unlike in mul you’re safely allowed *less* * than the available columns [255 per default] since carries * are fixed up in the inner loop. */ digs = n->used * 2 + 1; if ((digs < MP_WARRAY) && n->used < (1 alloc < digs) { if ((res = mp_grow (x, digs)) != MP_OKAY) {
6.3 The Montgomery Reduction 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074 075 076 077 078 079 080 081
165
return res; } } x->used = digs; for (ix = 0; ix < n->used; ix++) { /* mu = ai * rho mod b * * The value of rho must be precalculated via * montgomery_setup() such that * it equals -1/n0 mod b this allows the * following inner loop to reduce the * input one digit at a time */ mu = (mp_digit) (((mp_word)x->dp[ix]) * ((mp_word)rho) & MP_MASK); /* a = a + { register register register
mu * m * b**i */ int iy; mp_digit *tmpn, *tmpx, u; mp_word r;
/* alias for digits of the modulus */ tmpn = n->dp; /* alias for the digits of x [the input] */ tmpx = x->dp + ix; /* set the carry to zero */ u = 0; /* Multiply and add in place */ for (iy = 0; iy < n->used; iy++) { /* compute product and sum */ r = ((mp_word)mu) * ((mp_word)*tmpn++) + ((mp_word) u) + ((mp_word) * tmpx); /* get carry */ u = (mp_digit)(r >> ((mp_word) DIGIT_BIT)); /* fix digit */
166 082 083 084 085 086 087 088 089 090 091 092 093 094 095 096 097 098 099 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
www.syngress.com *tmpx++ = (mp_digit)(r & ((mp_word) MP_MASK)); } /* At this point the ix’th digit of x should be zero */
/* propagate while (u) { *tmpx += u = *tmpx++ &= }
carries upwards as required*/ u; *tmpx >> DIGIT_BIT; MP_MASK;
} } /* at this point the n.used’th least * significant digits of x are all zero * which means we can shift x to the * right by n.used digits and the * residue is unchanged. */ /* x = x/b**n.used */ mp_clamp(x); mp_rshd (x, n->used); /* if x >= n then x = x - n */ if (mp_cmp_mag (x, n) != MP_LT) { return s_mp_sub (x, n, x); } return MP_OKAY; }
This is the baseline implementation of the Montgomery reduction algorithm. Lines 31 to 36 determine if the Comba–based routine can be used instead. Line 47 computes the value of µ for that particular iteration of the outer loop. The multiplication µnβ ix is performed in one step in the inner loop. The alias tmpx refers to the ix’th digit of x, and the alias tmpn refers to the modulus n.
6.3 The Montgomery Reduction
6.3.3
167
Faster “Comba” Montgomery Reduction
The Montgomery reduction requires fewer single precision multiplications than a Barrett reduction; however, it is much slower due to the serial nature of the inner loop. The Barrett reduction algorithm requires two slightly modified multipliers, which can be implemented with the Comba technique. The Montgomery reduction algorithm cannot directly use the Comba technique to any significant advantage since the inner loop calculates a k × 1 product k times. The biggest obstacle is that at the ix’th iteration of the outer loop, the value of xix is required to calculate µ. This means the carries from 0 to ix − 1 must have been propagated upwards to form a valid ix’th digit. The solution as it turns out is very simple. Perform a Comba–like multiplier, and inside the outer loop just after the inner loop, fix up the ix + 1’th digit by forwarding the carry. With this change in place, the Montgomery reduction algorithm can be performed with a Comba–style multiplication loop, which substantially increases the speed of the algorithm.
168
www.syngress.com Algorithm fast mp montgomery reduce. Input. mp int x, mp int n and a digit ρ ≡ −1/n0 (mod n). (0 ≤ x < n2 , n > 1, (n, β) = 1, β k > n) Output. β −k x (mod n) ˆ on the stack. Place an array of MP WARRAY mp word variables called W 1. if x.alloc < n.used + 1 then grow x to n.used + 1 digits. ˆ Copy the digits of x into the array W 2. For ix from 0 to x.used − 1 do ˆ ix ← xix 2.1 W 3. For ix from x.used to 2n.used − 1 do ˆ ix ← 0 3.1 W Eliminate the lower k digits. 4. for ix from 0 to n.used − 1 do ˆ ix · ρ (mod β) 4.1 µ ← W 4.2 For iy from 0 to n.used − 1 do ˆ iy+ix ← W ˆ iy+ix + µ · niy 4.2.1 W ˆ ix+1 ← W ˆ ix+1 + ⌊W ˆ ix /β⌋ 4.3 W Propagate the rest of the carries upwards. 5. for ix from n.used to 2n.used + 1 do ˆ ix+1 ← W ˆ ix+1 + ⌊W ˆ ix /β⌋ 5.1 W Shift right and reduce modulo β simultaneously. 6. for ix from 0 to n.used + 1 do ˆ ix+n.used (mod β) 6.1 xix ← W Zero excess digits and fixup x. 7. if x.used > n.used + 1 then do 7.1 for ix from n.used + 1 to x.used − 1 do 7.1.1 xix ← 0 8. x.used ← n.used + 1 9. Clamp excessive digits of x. 10. If x ≥ n then 10.1 x ← x − n 11. Return(MP OKAY ).
Figure 6.10: Algorithm fast mp montgomery reduce Algorithm fast mp montgomery reduce. This algorithm will compute the Montgomery reduction of x modulo n using the Comba technique. It is on most computer platforms significantly faster than algorithm mp montgomery reduce
6.3 The Montgomery Reduction
169
and algorithm mp reduce (Barrett reduction). The algorithm has the same restrictions on the input as the baseline reduction algorithm. An additional two restrictions are imposed on this algorithm. The number of digits k in the modulus n must not violate M P W ARRAY > 2k + 1 and n < δ. When β = 228 , this algorithm can be used to reduce modulo a modulus of at most 3, 556 bits in length (Figure 6.10). ˆ array that stores As in the other Comba reduction algorithms there is a W the columns of the product. It is initially filled with the contents of x with the excess digits zeroed. The reduction loop is very similar the to the baseline loop at heart. The multiplication in step 4.1 can be single precision only, since ab (mod β) ≡ (a mod β)(b mod β). Some multipliers such as those on the ARM processors take a variable length time to complete depending on the number of bytes of result it must produce. By performing a single precision multiplication instead, half the amount of time is spent. ˆ ix must have the carry from the ix−1’th digit propagated Also note that digit W upwards for this to work. That is what step 4.3 will do. In effect, over the n.used iterations of the outer loop the n.used’th lower columns all have their carries propagated forwards. Note how the upper bits of those same words are not reduced modulo β. This is because those values will be discarded shortly and there is no point. Step 5 will propagate the remainder of the carries upwards. In step 6, the columns are reduced modulo β and shifted simultaneously as they are stored in the destination x. File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031
bn fast mp montgomery reduce.c /* computes xR**-1 == x (mod N) via Montgomery Reduction * * This is an optimized implementation of montgomery_reduce * which uses the comba method to quickly calculate the columns of the * reduction. * * Based on Algorithm 14.32 on pp.601 of HAC. */ int fast_mp_montgomery_reduce (mp_int * x, mp_int * n, mp_digit rho) { int ix, res, olduse; mp_word W[MP_WARRAY]; /* get old used count */
170 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072
www.syngress.com olduse = x->used; /* grow a as required */ if (x->alloc < n->used + 1) { if ((res = mp_grow (x, n->used + 1)) != MP_OKAY) { return res; } } /* first we have to get the digits of the input into * an array of double precision words W[...] */ { register mp_word *_W; register mp_digit *tmpx; /* alias for the W[] array */ _W = W; /* alias for the digits of tmpx = x->dp;
x*/
/* copy the digits of a into W[0..a->used-1] */ for (ix = 0; ix < x->used; ix++) { *_W++ = *tmpx++; } /* zero the high words of W[a->used..m->used*2] */ for (; ix < n->used * 2 + 1; ix++) { *_W++ = 0; } } /* now we proceed to zero successive digits * from the least significant upwards */ for (ix = 0; ix < n->used; ix++) { /* mu = ai * m’ mod b * * We avoid a double precision multiplication (which isn’t required) * by casting the value down to a mp_digit. Note this requires
6.3 The Montgomery Reduction 073 074 075 076 077 078 079 080 081 082 083 084 085 086 087 088 089 090 091 092 093 094 095 096 097 098 099 100 101 102 103 104 105 106 107 108 109 110 111 112 113
171
* that W[ix-1] have the carry cleared (see after the inner loop) */ register mp_digit mu; mu = (mp_digit) (((W[ix] & MP_MASK) * rho) & MP_MASK); /* a = a + mu * m * b**i * * This is computed in place and on the fly. The multiplication * by b**i is handled by offsetting which columns the results * are added to. * * Note the comba method normally doesn’t handle carries in the * inner loop In this case we fix the carry from the previous * column since the Montgomery reduction requires digits of the * result (so far) [see above] to work. This is * handled by fixing up one carry after the inner loop. The * carry fixups are done in order so after these loops the * first m->used words of W[] have the carries fixed */ { register int iy; register mp_digit *tmpn; register mp_word *_W; /* alias for the digits of the modulus */ tmpn = n->dp; /* Alias for the columns set by an offset of ix */ _W = W + ix; /* inner loop */ for (iy = 0; iy < n->used; iy++) { *_W++ += ((mp_word)mu) * ((mp_word)*tmpn++); } } /* now fix carry for next digit, W[ix+1] */ W[ix + 1] += W[ix] >> ((mp_word) DIGIT_BIT); } /* now we have to propagate the carries and
172 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
www.syngress.com * shift the words downward [all those least * significant digits we zeroed]. */ { register mp_digit *tmpx; register mp_word *_W, *_W1; /* nox fix rest of carries */ /* alias for current word */ _W1 = W + ix; /* alias for next word, where the carry goes */ _W = W + ++ix; for (; ix used * 2 + 1; ix++) { *_W++ += *_W1++ >> ((mp_word) DIGIT_BIT); } /* copy out, A = A/b**n * * The result is A/b**n but instead of converting from an * array of mp_word to mp_digit then calling mp_rshd * we just copy them in the right order */ /* alias for destination word */ tmpx = x->dp; /* alias for shifted double precision result */ _W = W + n->used; for (ix = 0; ix < n->used + 1; ix++) { *tmpx++ = (mp_digit)(*_W++ & ((mp_word) MP_MASK)); } /* zero oldused digits, if the input a was larger than * m->used+1 we’ll have to clear the digits */ for (; ix < olduse; ix++) { *tmpx++ = 0;
6.3 The Montgomery Reduction 155 156 157 158 159 160 161 162 163 164 165 166 167 168
173
} } /* set the max used and clamp */ x->used = n->used + 1; mp_clamp (x); /* if A >= m then A = A - m */ if (mp_cmp_mag (x, n) != MP_LT) { return s_mp_sub (x, n, x); } return MP_OKAY; }
ˆ array is first filled with digits of x on line 55, then the rest of the digits The W are zeroed on line 60. Both loops share the same alias variables to make the code easier to read. ˆ ix is The value of µ is calculated in an interesting fashion. First, the value W reduced modulo β and cast to a mp digit. This forces the compiler to use a single precision multiplication and prevents any concerns about loss of precision. Line 110 fixes the carry for the next iteration of the loop by propagating the carry from ˆ ix to W ˆ ix+1 . W The for loop on line 129 propagates the rest of the carries upwards through the columns. The for loop on line 146 reduces the columns modulo β and shifts them ˆ actually refers to the array W ˆ starting k places at the same time. The alias W ˆt = W ˆ n.used+t . at the n.used’th digit, that is W
6.3.4
Montgomery Setup
To calculate the variable ρ, a relatively simple algorithm will be required.
174
www.syngress.com Algorithm mp montgomery setup. Input. mp int n (n > 1 and (n, 2) = 1) Output. ρ ≡ −1/n0 (mod β) 1. 2. 3. 4.
b ← n0 If b is even return(MP VAL) x ← (((b + 2) AND 4) (X(2-XA)) A = 1 (mod 2**2n) * => 2*X*A - X*X*A*A = 1 * => 2*(1) - (1) = 1 */ b = n->dp[0]; if ((b & 1) == 0) { return MP_VAL; } x = (((b + 2) & 4) dp; /* alias for upper half of x, or x/B**m */
6.4 The Diminished Radix Algorithm 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074 075 076 077 078 079 080 081 082 083 084 085 086 087 088 089 090
181
tmpx2 = x->dp + m; /* set carry to zero */ mu = 0; /* compute (x for (i = 0; i r *tmpx1++ mu }
mod B**m) + k * [x/B**m] inline and inplace */ < m; i++) { = ((mp_word)*tmpx2++) * ((mp_word)k) + *tmpx1 + mu; = (mp_digit)(r & MP_MASK); = (mp_digit)(r >> ((mp_word)DIGIT_BIT));
/* set final carry */ *tmpx1++ = mu; /* zero words above m */ for (i = m + 1; i < x->used; i++) { *tmpx1++ = 0; } /* clamp, sub and return */ mp_clamp (x); /* if x >= n then subtract and reduce again * Each successive "recursion" makes the input smaller and smaller. */ if (mp_cmp_mag (x, n) != MP_LT) { s_mp_sub(x, n, x); goto top; } return MP_OKAY; }
The first step is to grow x as required to 2m digits, since the reduction is performed in place on x. The label on line 52 is where the algorithm will resume if further reduction passes are required. In theory, it could be placed at the top of the function. However, the size of the modulus and question of whether x is large enough are invariant after the first pass, meaning that it would be a waste of time. The aliases tmpx1 and tmpx2 refer to the digits of x, where the latter is offset
182
www.syngress.com
by m digits. By reading digits from x offset by m digits, a division by β m can be simulated virtually for free. The loop on line 64 performs the bulk of the work (corresponds to step 4 of algorithm 7.11 ) in this algorithm. By line 67 the pointer tmpx1 points to the m’th digit of x, which is where the final carry will be placed. Similarly, by line 74 the same pointer will point to the m + 1’th digit where the zeroes will be placed. Since the algorithm is only valid if both x and n are greater than zero, an unsigned comparison suffices to determine if another pass is required. With the same logic at line 81 the value of x is known to be greater than or equal to n, meaning that an unsigned subtraction can be used as well. Since the destination of the subtraction is the larger of the inputs, the call to algorithm s mp sub cannot fail and the return code does not need to be checked. Setup To set up the Restricted Diminished Radix algorithm the value k = β − n0 is required. This algorithm is not complicated but is provided for completeness (Figure 6.15). Algorithm mp dr setup. Input. mp int n Output. k = β − n0 1. k ← β − n0
Figure 6.15: Algorithm mp dr setup File: 018 019 020 021 022 023 024 025 026 027 028
bn mp dr setup.c /* determines the setup value */ void mp_dr_setup(mp_int *a, mp_digit *d) { /* the casts are required if DIGIT_BIT is one less than * the number of bits in a mp_digit [e.g. DIGIT_BIT==31] */ *d = (mp_digit)((((mp_word)1) dp[0])); }
6.4 The Diminished Radix Algorithm
183
Modulus Detection Another useful algorithm gives the ability to detect a Restricted Diminished Radix modulus. An integer is said to be of Restricted Diminished Radix form if all the digits are equal to β − 1 except the trailing digit, which may be any value. Algorithm mp dr is modulus. Input. mp int n Output. 1 if n is in D.R form, 0 otherwise 1. If n.used < 2 then return(0). 2. for ix from 1 to n.used − 1 do 2.1 If nix 6= β − 1 return(0). 3. Return(1).
Figure 6.16: Algorithm mp dr is modulus Algorithm mp dr is modulus. This algorithm determines if a value is in Diminished Radix form. Step 1 rejects obvious cases where fewer than two digits are in the mp int. Step 2 tests all but the first digit to see if they are equal to β − 1. If the algorithm manages to get to step 3, then n must be of Diminished Radix form (Figure 6.16). File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034
bn mp dr is modulus.c /* determines if a number is a valid DR modulus */ int mp_dr_is_modulus(mp_int *a) { int ix; /* must be at least two digits */ if (a->used < 2) { return 0; } /* must be of the form b**k - a [a used; ix++) { if (a->dp[ix] != MP_MASK) { return 0; }
184 035 036 037 038 039
6.4.4
www.syngress.com } return 1; }
Unrestricted Diminished Radix Reduction
The unrestricted Diminished Radix algorithm allows modular reductions to be performed when the modulus is of the form 2p − k. This algorithm is a straightforward adaptation of algorithm 6.12. In general, the restricted Diminished Radix reduction algorithm is much faster since it has considerably lower overhead. However, this new algorithm is much faster than either Montgomery or Barrett reduction when the moduli are of the appropriate form. Algorithm mp reduce 2k. Input. mp int a and n. mp digit k (a ≥ 0, n > 1, 0 < k < β, n + k is a power of two) Output. a (mod n) 1. p ← ⌈lg(n)⌉ (mp count bits) 2. While a ≥ n do 2.1 q ← ⌊a/2p ⌋ (mp div 2d ) 2.2 a ← a (mod 2p ) (mp mod 2d ) 2.3 q ← q · k (mp mul d ) 2.4 a ← a − q (s mp sub) 2.5 If a ≥ n then do 2.5.1 a ← a − n 3. Return(MP OKAY ).
Figure 6.17: Algorithm mp reduce 2k Algorithm mp reduce 2k. This algorithm quickly reduces an input a modulo an unrestricted Diminished Radix modulus n. Division by 2p is emulated with a right shift, which makes the algorithm fairly inexpensive to use (Figure 6.17). File: bn mp reduce 2k.c 018 /* reduces a modulo n where n is of the form 2**p - d */ 019 int mp_reduce_2k(mp_int *a, mp_int *n, mp_digit d)
6.4 The Diminished Radix Algorithm 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057
185
{ mp_int q; int p, res; if ((res = mp_init(&q)) != MP_OKAY) { return res; } p = mp_count_bits(n); top: /* q = a/2**p, a = a mod 2**p */ if ((res = mp_div_2d(a, p, &q, a)) != MP_OKAY) { goto ERR; } if (d != 1) { /* q = q * d */ if ((res = mp_mul_d(&q, d, &q)) != MP_OKAY) { goto ERR; } } /* a = a + q */ if ((res = s_mp_add(a, &q, a)) != MP_OKAY) { goto ERR; } if (mp_cmp_mag(a, n) != MP_LT) { s_mp_sub(a, n, a); goto top; } ERR: mp_clear(&q); return res; }
The algorithm mp count bits calculates the number of bits in an mp int, which is used to find the initial value of p. The call to mp div 2d on line 31 calculates
186
www.syngress.com
both the quotient q and the remainder a required. By doing both in a single function call, the code size is kept fairly small. The multiplication by k is only performed if k > 1. This allows reductions modulo 2p − 1 to be performed without any multiplications. The unsigned s mp add, mp cmp mag, and s mp sub are used in place of their full sign counterparts since the inputs are only valid if they are positive. By using the unsigned versions, the overhead is kept to a minimum. Unrestricted Setup To set up this reduction algorithm, the value of k = 2p − n is required. Algorithm mp reduce 2k setup. Input. mp int n Output. k = 2p − n 1. p ← ⌈lg(n)⌉ (mp count bits) 2. x ← 2p (mp 2expt) 3. x ← x − n (mp sub) 4. k ← x0 5. Return(MP OKAY ).
Figure 6.18: Algorithm mp reduce 2k setup Algorithm mp reduce 2k setup. This algorithm computes the value of k required for the algorithm mp reduce 2k. By making a temporary variable x equal to 2p , a subtraction is sufficient to solve for k. Alternatively if n has more than one digit the value of k is simply β − n0 (Figure 6.18). File: 018 019 020 021 022 023 024 025 026 027
bn mp reduce 2k setup.c /* determines the setup value */ int mp_reduce_2k_setup(mp_int *a, mp_digit *d) { int res, p; mp_int tmp; if ((res = mp_init(&tmp)) != MP_OKAY) { return res; }
6.4 The Diminished Radix Algorithm 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043
187
p = mp_count_bits(a); if ((res = mp_2expt(&tmp, p)) != MP_OKAY) { mp_clear(&tmp); return res; } if ((res = s_mp_sub(&tmp, a, &tmp)) != MP_OKAY) { mp_clear(&tmp); return res; } *d = tmp.dp[0]; mp_clear(&tmp); return MP_OKAY; }
Unrestricted Detection An integer n is a valid unrestricted Diminished Radix modulus if either of the following are true. • The number has only one digit. • The number has more than one digit, and every bit from the β’th to the most significant is one. If either condition is true, there is a power of two 2p such that 0 < 2p − n < β. If the input is only one digit, it will always be of the correct form. Otherwise, all of the bits above the first digit must be one. This arises from the fact that there will be value of k that when added to the modulus causes a carry in the first digit that propagates all the way to the most significant bit. The resulting sum will be a power of two.
188
www.syngress.com Algorithm mp reduce is 2k. Input. mp int n Output. 1 if of proper form, 0 otherwise 1. If n.used = 0 then return(0). 2. If n.used = 1 then return(1). 3. p ← ⌈lg(n)⌉ (mp count bits) 4. for x from lg(β) to p do 4.1 If the (x mod lg(β))’th bit of the ⌊x/lg(β)⌋ of n is zero then return(0). 5. Return(1).
Figure 6.19: Algorithm mp reduce is 2k Algorithm mp reduce is 2k. This algorithm quickly determines if a modulus is of the form required for algorithm mp reduce 2k to function properly (Figure 6.19). File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040
bn mp reduce is 2k.c /* determines if mp_reduce_2k can be used */ int mp_reduce_is_2k(mp_int *a) { int ix, iy, iw; mp_digit iz; if (a->used == 0) { return MP_NO; } else if (a->used == 1) { return MP_YES; } else if (a->used > 1) { iy = mp_count_bits(a); iz = 1; iw = 1; /* Test every bit from the second digit up, must be 1 */ for (ix = DIGIT_BIT; ix < iy; ix++) { if ((a->dp[iw] & iz) == 0) { return MP_NO; } iz 1, those limitations are not included in the table. Method Barrett Montgomery D.R.
Work Required m2 + 2m − 1 m2 + m 2m
Limitations None n must be odd n = βm − k
m=8 79 72 16
m = 32 1087 1056 64
m = 64 4223 4160 128
In theory, Montgomery and Barrett reductions would require roughly the same amount of time to complete. However, in practice since Montgomery reduction can be written as a single function with the Comba technique, it is much faster. Barrett reduction suffers from the overhead of calling the half precision multipliers, addition and division by β algorithms. For almost every cryptographic algorithm, Montgomery reduction is the algorithm of choice. The one set of algorithms where Diminished Radix reduction truly shines is based on the discrete logarithm problem such as Diffie-Hellman and ElGamal. In these algorithms, primes of the form β m − k can be found and shared among users. These primes will allow the Diminished Radix algorithm to be used in modular exponentiation to greatly speed up the operation.
190
www.syngress.com
Exercises [3]
Prove that the “trick” in algorithm mp montgomery setup actually calculates the correct value of ρ.
[2]
Devise an algorithm to reduce modulo n + k for small k quickly.
[4]
Prove that the pseudo-code algorithm “Diminished Radix Reduction” (Figure 6.12) terminates. Also prove the probability that it will terminate within 1 ≤ k ≤ 10 iterations.
Chapter 7
Exponentiation Exponentiation is the operation of raising one variable to the power of another; for example, ab . A variant of exponentiation, computed in a finite field or ring, is called modular exponentiation. This latter style of operation is typically used in public key cryptosystems such as RSA and Diffie-Hellman. The ability to quickly compute modular exponentiations is of great benefit to any such cryptosystem, and many methods have been sought to speed it up.
7.1
Exponentiation Basics
A trivial algorithm would simply multiply a against itself b−1 times to compute the exponentiation desired. However, as b grows in size the number of multiplications becomes prohibitive. Imagine what would happen if b ∼ 21024 , as is the case when computing an RSA signature with a 1024-bit key. Such a calculation could never be completed, as it would take far too long. Fortunately, there is a very simple algorithm based on the laws of exponents. Recall that lga (ab ) = b and that lga (ab ac ) = b+c which are two trivial relationships between the base and the exponent. Let bi represent the i’th bit of b starting from the least significant bit. If b is a k-bit integer, equation 7.1 is true. ab =
k−1 Y i=0
191
i
a2
·bi
(7.1)
192
www.syngress.com
By taking the base a logarithm of both sides of the equation, equation 7.2 is the result. b=
k−1 X i=0
2i · bi
(7.2)
i
The term a2 can be found from the i − 1’th term by squaring the term, since i 2 i+1 a2 is equal to a2 . This observation forms the basis of essentially all fast
exponentiation algorithms. It requires k squarings and on average k2 multiplications to compute the result. This is indeed quite an improvement over simply multiplying by a a total of b − 1 times. While this current method is considerably faster, there are further improvei ments to be made. For example, the a2 term does not need to be computed in an auxiliary variable. Consider the equivalent algorithm in Figure 7.1. Algorithm Left to Right Exponentiation. Input. Integer a, b and k Output. c = ab 1. c ← 1 2. for i from k − 1 to 0 do 2.1 c ← c2 2.2 c ← c · abi 3. Return c.
Figure 7.1: Left to Right Exponentiation This algorithm starts from the most significant bit and works toward the least significant bit. When the i’th bit of b is set, a is multiplied against the current product. In each iteration the product is squared, which doubles the exponent of the individual terms of the product. For example, let b = 1011002 ≡ 4410 . Figure 7.2 demonstrates the actions of the algorithm.
193
7.1 Exponentiation Basics Value of i 5 4 3 2 1 0
Value of c 1 a a2 a4 · a a8 · a2 · a a16 · a4 · a2 a32 · a8 · a4
Figure 7.2: Example of Left to Right Exponentiation When the product a32 ·a8 ·a4 is simplified, it is equal to a44 , which is the desired exponentiation. This particular algorithm is called “Left to Right” because it reads the exponent in that order. All the exponentiation algorithms that will be presented are of this nature.
7.1.1
Single Digit Exponentiation
The first algorithm in the series of exponentiation algorithms will be an unbounded algorithm where the exponent is a single digit. It is intended to be used when a small power of an input is required (e.g., a5 ). It is faster than simply multiplying b − 1 times for all values of b that are greater than three.
194
www.syngress.com Algorithm mp expt d. Input. mp int a and mp digit b Output. c = ab 1. g ← a (mp init copy) 2. c ← 1 (mp set) 3. for x from 1 to lg(β) do 3.1 c ← c2 (mp sqr ) 3.2 If b AND 2lg(β)−1 6= 0 then 3.2.1 c ← c · g (mp mul ) 3.3 b ← b > > > > > > < 2. winsize ← > > > > > > > > :
2 3 4 5 6 7 8
if k ≤ 7 if 7 < k ≤ 36 if 36 < k ≤ 140 if 140 < k ≤ 450 if 450 < k ≤ 1303 if 1303 < k ≤ 3529 if 3529 < k 3. Initialize 2winsize mp ints in an array named M and one mp int named µ 4. Calculate the µ required for Barrett Reduction (mp reduce setup). 5. M1 ← g (mod p) winsize
Set up the table of small powers of g. First find g 2 6. k ← 2winsize−1 7. Mk ← M1 8. for ix from 0 to winsize − 2 do 8.1 Mk ← (Mk )2 (mp sqr ) 8.2 Mk ← Mk (mod p) (mp reduce) 9. for ix from 2winsize−1 + 1 to 2winsize − 1 do 9.1 Mix ← Mix−1 · M1 (mp mul ) 9.2 Mix ← Mix (mod p) (mp reduce) 10. res ← 1
and then all the multiples of it.
Start Sliding Window. 11. mode ← 0, bitcnt ← 1, buf ← 0, digidx ← x.used − 1, bitcpy ← 0, bitbuf ← 0 Continued on next page.
204
www.syngress.com Algorithm s mp exptmod (continued ). Input. mp int a, b and c Output. y ≡ g x (mod p) 12. Loop 12.1 bitcnt ← bitcnt − 1 12.2 If bitcnt = 0 then do 12.2.1 If digidx = −1 goto step 13. 12.2.2 buf ← xdigidx 12.2.3 digidx ← digidx − 1 12.2.4 bitcnt ← lg(β) 12.3 y ← (buf >> (lg(β) − 1)) AND 1 12.4 buf ← buf 1 || a->dp[0] >= b)) { /* temporarily fix sign of a */
8.2 Single Digit Helpers 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074 075
a->sign = MP_ZPOS; /* c = |a| - b */ res = mp_sub_d(a, b, c); /* fix sign */ a->sign = c->sign = MP_NEG; /* clamp */ mp_clamp(c); return res; } /* old number of used digits in c */ oldused = c->used; /* sign always positive */ c->sign = MP_ZPOS; /* source alias */ tmpa = a->dp; /* destination alias */ tmpc = c->dp; /* if a is positive */ if (a->sign == MP_ZPOS) { /* add digit, after this we’re propagating * the carry. */ *tmpc = *tmpa++ + b; mu = *tmpc >> DIGIT_BIT; *tmpc++ &= MP_MASK; /* now handle rest of the digits */ for (ix = 1; ix < a->used; ix++) { *tmpc = *tmpa++ + mu; mu = *tmpc >> DIGIT_BIT; *tmpc++ &= MP_MASK; }
233
234 076 077 078 079 080 081 082 083 084 085 086 087 088 089 090 091 092 093 094 095 096 097 098 099 100 101 102 103 104 105 106 107 108
www.syngress.com /* set final carry */ ix++; *tmpc++ = mu; /* setup size */ c->used = a->used + 1; } else { /* a was negative and |a| < b */ c->used = 1; /* the result is a single digit */ if (a->used == 1) { *tmpc++ = b - a->dp[0]; } else { *tmpc++ = b; } /* setup count so the clearing of oldused * can fall through correctly */ ix = 1; } /* now zero to oldused */ while (ix++ < oldused) { *tmpc++ = 0; } mp_clamp(c); return MP_OKAY; }
Unlike the simple description in Figure 8.3, the implementation is more complicated. This is because we want to avoid the cost of building a new mp int temporary variable just for a simple addition. First, we handle the case of negative numbers (line 33). If the number is negative, and sufficiently large, then we subtract instead. After this point, we are going to add a single digit (line 66), and then propagate the carry upwards (lines 71 through 78).
8.2 Single Digit Helpers
235
Subtraction The single digit subtraction algorithm mp sub d is essentially the same, except it uses mp sub to subtract the digit from the mp int.
8.2.2
Single Digit Multiplication
Single digit multiplication arises enough in division and radix conversion that it ought to be implemented as a special case of the baseline multiplication algorithm. Essentially, this algorithm is a modified version of algorithm s mp mul digs where one of the multiplicands only has one digit. Algorithm mp mul d. Input. mp int a and a mp digit b Output. c = ab 1. 2. 3. 4. 5. 6. 7.
pa ← a.used Grow c to at least pa + 1 digits. oldused ← c.used c.used ← pa + 1 c.sign ← a.sign µ←0 for ix from 0 to pa − 1 do 7.1 rˆ ← µ + aix b 7.2 cix ← rˆ (mod β) 7.3 µ ← ⌊ˆ r /β⌋ 8. cpa ← µ 9. for ix from pa + 1 to oldused do 9.1 cix ← 0 10. Clamp excess digits of c. 11. Return(MP OKAY ).
Figure 8.4: Algorithm mp mul d Algorithm mp mul d. This algorithm quickly multiplies an mp int by a small single digit value. It is specially tailored to the job and has minimal overhead. Unlike the full multiplication algorithms, this algorithm does not require any significant temporary storage or memory allocations (Figure 8.4).
236 File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057
www.syngress.com bn mp mul d.c /* multiply by a digit */ int mp_mul_d (mp_int * a, mp_digit b, mp_int * c) { mp_digit u, *tmpa, *tmpc; mp_word r; int ix, res, olduse; /* make sure c is big enough to hold a*b */ if (c->alloc < a->used + 1) { if ((res = mp_grow (c, a->used + 1)) != MP_OKAY) { return res; } } /* get the original destinations used count */ olduse = c->used; /* set the sign */ c->sign = a->sign; /* alias for a->dp [source] */ tmpa = a->dp; /* alias for c->dp [dest] */ tmpc = c->dp; /* zero carry */ u = 0; /* compute columns */ for (ix = 0; ix < a->used; ix++) { /* compute product and carry sum for this term */ r = ((mp_word) u) + ((mp_word)*tmpa++) * ((mp_word)b); /* mask off higher bits to get a single digit */ *tmpc++ = (mp_digit) (r & ((mp_word) MP_MASK)); /* send carry into next iteration */ u = (mp_digit) (r >> ((mp_word) DIGIT_BIT));
237
8.2 Single Digit Helpers 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074 075
} /* store final carry [if any] and increment ix offset *tmpc++ = u; ++ix;
*/
/* now zero digits above the top */ while (ix++ < olduse) { *tmpc++ = 0; } /* set used count */ c->used = a->used + 1; mp_clamp(c); return MP_OKAY; }
In this implementation, the destination c may point to the same mp int as the source a, since the result is written after the digit is read from the source. This function uses pointer aliases tmpa and tmpc for the digits of a and c, respectively.
8.2.3
Single Digit Division
Like the single digit multiplication algorithm, single digit division is also a fairly common algorithm used in radix conversion. Since the divisor is only a single digit, a specialized variant of the division algorithm can be used to compute the quotient.
238
www.syngress.com Algorithm mp div d. Input. mp int a and a mp digit b Output. c = ⌊a/b⌋, d = a − cb 1. 2. 3. 4. 5. 6. 7.
If b = 0 then return(MP VAL). If b = 3 then use algorithm mp div 3 instead. Init q to a.used digits. q.used ← a.used q.sign ← a.sign w ˆ←0 for ix from a.used − 1 down to 0 do 7.1 w ˆ ← wβ ˆ + aix 7.2 If w ˆ ≥ b then 7.2.1 t ← ⌊w/b⌋ ˆ 7.2.2 w ˆ←w ˆ (mod b) 7.3 else 7.3.1 t ← 0 7.4 qix ← t 8. d ← w ˆ 9. Clamp excess digits of q. 10. c ← q 11. Return(MP OKAY ).
Figure 8.5: Algorithm mp div d Algorithm mp div d. This algorithm divides the mp int a by the single mp digit b using an optimized approach. Essentially, in every iteration of the algorithm another digit of the dividend is reduced and another digit of quotient produced. Provided b < β, the value of w ˆ after step 7.1 will be limited such that 0 ≤ ⌊w/b⌋ ˆ < β (Figure 8.5). If the divisor b is equal to three a variant of this algorithm is used, which is mp div 3. It replaces the division by three with a multiplication by ⌊β/3⌋ and the appropriate shift and residual fixup. In essence, it is much like the Barrett reduction from Chapter 7. File: bn mp div d.c 018 static int s_is_power_of_two(mp_digit b, int *p) 019 { 020 int x; 021
8.2 Single Digit Helpers 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062
for (x = 1; x < DIGIT_BIT; x++) { if (b == (((mp_digit)1)dp[0] & ((((mp_digit)1)used; q.sign = a->sign; w = 0; for (ix = a->used - 1; ix >= 0; ix--) { w = (w dp[ix]); if (w >= b) { t = (mp_digit)(w / b); w -= ((mp_word)t) * ((mp_word)b); } else { t = 0; } q.dp[ix] = (mp_digit)t; } if (d != NULL) { *d = (mp_digit)w; } if (c != NULL) { mp_clamp(&q); mp_exch(&q, c); } mp_clear(&q); return res;
241
8.2 Single Digit Helpers 104 105 106
}
Like the implementation of algorithm mp div, this algorithm allows either the quotient or remainder to be passed as a NULL pointer to indicate the respective value is not required. This allows a trivial single digit modular reduction algorithm, mp mod d, to be created. The division and remainder on lines 85 and 86 can be replaced often by a single division on most processors. For example, the 32-bit x86 based processors can divide a 64-bit quantity by a 32-bit quantity and produce the quotient and remainder simultaneously. Unfortunately, the GCC compiler does not recognize that optimization and will actually produce two function calls to find the quotient and remainder, respectively.
8.2.4
Single Digit Root Extraction
Finding the n’th root of an integer is fairly easy as far as numerical analysis is concerned. Algorithms such as the Newton-Raphson approximation (8.6) series will converge very quickly to a root for any continuous function f (x). xi+1 = xi −
f (xi ) f ′ (xi )
(8.6)
In this case, the n’th root is desired and f (x) = xn − a, where a is the integer of which the root is desired. The derivative of f (x) is simply f ′ (x) = nxn−1 . Of particular importance is that this algorithm will be used over the integers, not over a more continuous domain such as the real numbers. As a result, the root found can be above the true root by few and must be manually adjusted. Ideally, at the end of the algorithm the n’th root b of an integer a is desired such that bn ≤ a.
242
www.syngress.com Algorithm mp n root. Input. mp int a and a mp digit b Output. cb ≤ a 1. 2. 3. 4. 5.
If b is even and a.sign = M P N EG return(MP VAL). sign ← a.sign a.sign ← M P ZP OS t2 ← 2 Loop 5.1 t1 ← t2 5.2 t3 ← t1b−1 5.3 t2 ← t3 · t1 5.4 t2 ← t2 − a 5.5 t3 ← t3 · b 5.6 t3 ← ⌊t2/t3⌋ 5.7 t2 ← t1− t3 5.8 If t1 6= t2 then goto step 5. 6. Loop 6.1 t2 ← t1b 6.2 If t2 > a then 6.2.1 t1 ← t1 − 1 6.2.2 Goto step 6. 7. a.sign ← sign 8. c ← t1 9. c.sign ← sign 10. Return(MP OKAY ).
Figure 8.6: Algorithm mp n root Algorithm mp n root. This algorithm finds the integer n’th root of an input using the Newton-Raphson approach. It is partially optimized based on the observation that the numerator of ff′(x) (x) can be derived from a partial denominator. That is, at first the denominator is calculated by finding xb−1 . This value can then be multiplied by x and have a subtracted from it to find the numerator. This saves a total of b − 1 multiplications by t1 inside the loop (Figure 8.6). The initial value of the approximation is t2 = 2, which allows the algorithm to start with very small values and quickly converge on the root. Ideally, this algorithm is meant to find the n’th root of an input where n is bounded by 2 ≤ n ≤ 5.
8.2 Single Digit Helpers File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057
bn mp n root.c /* find the n’th root of an integer * * Result found such that (c)**b a * * This algorithm uses Newton’s approximation * x[i+1] = x[i] - f(x[i])/f’(x[i]) * which will find the root in log(N) time where * each step involves a fair bit. This is not meant to * find huge roots [square and cube, etc]. */ int mp_n_root (mp_int * a, mp_digit b, mp_int * c) { mp_int t1, t2, t3; int res, neg; /* input must be positive if b is even */ if ((b & 1) == 0 && a->sign == MP_NEG) { return MP_VAL; } if ((res = mp_init (&t1)) != MP_OKAY) { return res; } if ((res = mp_init (&t2)) != MP_OKAY) { goto LBL_T1; } if ((res = mp_init (&t3)) != MP_OKAY) { goto LBL_T2; } /* if a is negative fudge the sign but keep track */ neg = a->sign; a->sign = MP_ZPOS; /* t2 = 2 */ mp_set (&t2, 2); do {
243
244 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074 075 076 077 078 079 080 081 082 083 084 085 086 087 088 089 090 091 092 093 094 095 096 097 098
www.syngress.com /* t1 = t2 */ if ((res = mp_copy (&t2, &t1)) != MP_OKAY) { goto LBL_T3; } /* t2 = t1 - ((t1**b - a) / (b * t1**(b-1))) */ /* t3 = t1**(b-1) */ if ((res = mp_expt_d (&t1, b - 1, &t3)) != MP_OKAY) { goto LBL_T3; } /* numerator */ /* t2 = t1**b */ if ((res = mp_mul (&t3, &t1, &t2)) != MP_OKAY) { goto LBL_T3; } /* t2 = t1**b - a */ if ((res = mp_sub (&t2, a, &t2)) != MP_OKAY) { goto LBL_T3; } /* denominator */ /* t3 = t1**(b-1) * b */ if ((res = mp_mul_d (&t3, b, &t3)) != MP_OKAY) { goto LBL_T3; } /* t3 = (t1**b - a)/(b * t1**(b-1)) */ if ((res = mp_div (&t2, &t3, &t3, NULL)) != MP_OKAY) { goto LBL_T3; } if ((res = mp_sub (&t1, &t3, &t2)) != MP_OKAY) { goto LBL_T3; } } while (mp_cmp (&t1, &t2) != MP_EQ); /* result can be off by a few so check */ for (;;) {
8.3 Random Number Generation 099 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
8.3
245
if ((res = mp_expt_d (&t1, b, &t2)) != MP_OKAY) { goto LBL_T3; } if (mp_cmp (&t2, a) == MP_GT) { if ((res = mp_sub_d (&t1, 1, &t1)) != MP_OKAY) { goto LBL_T3; } } else { break; } } /* reset the sign of a first */ a->sign = neg; /* set the result */ mp_exch (&t1, c); /* set the sign of the result */ c->sign = neg; res = MP_OKAY; LBL_T3:mp_clear (&t3); LBL_T2:mp_clear (&t2); LBL_T1:mp_clear (&t1); return res; }
Random Number Generation
Random numbers come up in a variety of activities, from public key cryptography to simple simulations and various randomized algorithms. Pollard-Rho factoring, for example, can make use of random values as starting points to find factors of a composite integer. In this case, the algorithm presented is solely for simulations and not intended for cryptographic use.
246
www.syngress.com Algorithm mp rand. Input. An integer b Output. A pseudo-random number of b digits 1. 2. 3. 4. 5.
a←0 If b ≤ 0 return(MP OKAY ) Pick a non-zero random digit d. a ← a+d for ix from 1 to d − 1 do 5.1 a ← a · β 5.2 Pick a random digit d. 5.3 a ← a + d 6. Return(MP OKAY ).
Figure 8.7: Algorithm mp rand Algorithm mp rand. This algorithm produces a pseudo-random integer of b digits. By ensuring that the first digit is non-zero, the algorithm also guarantees that the result has at least b digits. It relies heavily on a third-part random number generator, which should ideally generate uniformly all of the integers from 0 to β − 1 (Figure 8.7). File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034
bn mp rand.c /* makes a pseudo-random int of a given size */ int mp_rand (mp_int * a, int digits) { int res; mp_digit d; mp_zero (a); if (digits 0) { if ((res = mp_lshd (a, 1)) != MP_OKAY) { return res; } if ((res = mp_add_d (a, ((mp_digit) abs (rand ())), a)) != MP_OKAY) { return res; } } return MP_OKAY; }
Formatted Representations
The ability to emit a radix-n textual representation of an integer is useful for interacting with human parties. For example, the ability to be given a string of characters such as “114585” and turn it into the radix-β equivalent would make it easier to enter numbers into a program.
8.4.1
Reading Radix-n Input
For the purposes of this text we will assume that a simple lower ASCII map (Figure 8.8) is used for the values of from 0 to 63 to printable characters. For example, when the character “N” is read it represents the integer 23. The first 16 characters of the map are for the common representations up to hexadecimal. After that, they match the “base64” encoding scheme suitably chosen such that they are printable. While outputting as base64 may not be too helpful for human operators, it does allow communication via non–binary mediums.
248
www.syngress.com Value 0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60
Char 0 4 8 C G K O S W a e i m q u y
Value 1 5 9 13 17 21 25 29 33 37 41 45 49 53 57 61
Char 1 5 9 D H L P T X b f j n r v z
Value 2 6 10 14 18 22 26 30 34 38 42 46 50 54 58 62
Char 2 6 A E I M Q U Y c g k o s w +
Figure 8.8: Lower ASCII Map
Value 3 7 11 15 19 23 27 31 35 39 43 47 51 55 59 63
Char 3 7 B F J N R V Z d h l p t x /
8.4 Formatted Representations
249
Algorithm mp read radix. Input. A string str of length sn and radix r. Output. The radix-β equivalent mp int. 1. If r < 2 or r > 64 return(MP VAL). 2. ix ← 0 3. If str0 = “-” then do 3.1 ix ← ix + 1 3.2 sign ← M P N EG 4. else 4.1 sign ← M P ZP OS 5. a ← 0 6. for iy from ix to sn − 1 do 6.1 Let y denote the position in the map of striy . 6.2 If striy is not in the map or y ≥ r then goto step 7. 6.3 a ← a · r 6.4 a ← a + y 7. If a 6= 0 then a.sign ← sign 8. Return(MP OKAY ).
Figure 8.9: Algorithm mp read radix Algorithm mp read radix. This algorithm will read an ASCII string and produce the radix-β mp int representation of the same integer. A minus symbol “” may precede the string to indicate the value is negative; otherwise, it is assumed positive. The algorithm will read up to sn characters from the input and will stop when it reads a character it cannot map. The algorithm stops reading characters from the string, which allows numbers to be embedded as part of larger input without any significant problem (Figure 8.9). File: 018 019 020 021 022 023 024 025 026
bn mp read radix.c /* read a string [ASCII] in a given radix */ int mp_read_radix (mp_int * a, const char *str, int radix) { int y, res, neg; char ch; /* zero the digit bignum */ mp_zero(a);
250 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065 066 067
www.syngress.com /* make sure the radix is ok */ if (radix < 2 || radix > 64) { return MP_VAL; } /* if the leading digit is a * minus set the sign to negative. */ if (*str == ’-’) { ++str; neg = MP_NEG; } else { neg = MP_ZPOS; } /* set the integer to the default of zero */ mp_zero (a); /* process each digit of the string */ while (*str) { /* if the radix < 36 the conversion is case insensitive * this allows numbers like 1AB and 1ab to represent the same * [e.g. in hex] */ ch = (char) ((radix < 36) ? toupper (*str) : *str); for (y = 0; y < 64; y++) { if (ch == mp_s_rmap[y]) { break; } } /* if the char was found in the map * and is less than the given radix add it * to the number, otherwise exit the loop. */ if (y < radix) { if ((res = mp_mul_d (a, (mp_digit) radix, a)) != MP_OKAY) { return res; } if ((res = mp_add_d (a, (mp_digit) y, a)) != MP_OKAY) { return res;
value
8.4 Formatted Representations 068 069 070 071 072 073 074 075 076 077 078 079 080 081
} } else { break; } ++str; } /* set the sign only if a != 0 */ if (mp_iszero(a) != 1) { a->sign = neg; } return MP_OKAY; }
251
252
8.4.2
www.syngress.com
Generating Radix-n Output
Generating radix-n output is fairly trivial with a division and remainder algorithm. Algorithm mp toradix. Input. A mp int a and an integer r Output. The radix-r representation of a 1. 2. 3. 4. 5.
If r < 2 or r > 64 return(MP VAL). If a = 0 then str = “0” and return(MP OKAY ). t←a str ← “” if t.sign = M P N EG then 5.1 str ← str+ “-” 5.2 t.sign = M P ZP OS 6. While (t 6= 0) do 6.1 d ← t (mod r) 6.2 t ← ⌊t/r⌋ 6.3 Look up d in the map and store the equivalent character in y. 6.4 str ← str + y 7. If str0 =“−” then 7.1 Reverse the digits str1 , str2 , . . . strn . 8. Otherwise 8.1 Reverse the digits str0 , str1 , . . . strn . 9. Return(MP OKAY ).
Figure 8.10: Algorithm mp toradix Algorithm mp toradix. This algorithm computes the radix-r representation of an mp int a. The “digits” of the representation are extracted by reducing successive powers of ⌊a/rk ⌋ the input modulo r until rk > a. Note that instead of actually dividing by rk in each iteration, the quotient ⌊a/r⌋ is saved for the next iteration. As a result, a series of trivial n × 1 divisions are required instead of a series of n × k divisions. One design flaw of this approach is that the digits are produced in the reverse order (see 8.11). To remedy this flaw, the digits must be swapped or simply “reversed” (Figure 8.10).
253
8.4 Formatted Representations Value of a 1234 123 12 1 0
Value of d – 4 3 2 1
Value of str – “4” “43” “432” “4321”
Figure 8.11: Example of Algorithm mp toradix. Figure 8.11 is an example of the values in algorithm mp toradix at the various iterations. File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043
bn mp toradix.c /* stores a bignum as a ASCII string in a given radix (2..64) */ int mp_toradix (mp_int * a, char *str, int radix) { int res, digs; mp_int t; mp_digit d; char *_s = str; /* check range of the radix */ if (radix < 2 || radix > 64) { return MP_VAL; } /* quick out if its zero */ if (mp_iszero(a) == 1) { *str++ = ’0’; *str = ’\0’; return MP_OKAY; } if ((res = mp_init_copy (&t, a)) != MP_OKAY) { return res; } /* if it is negative output a - */ if (t.sign == MP_NEG) {
254 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071
www.syngress.com ++_s; *str++ = ’-’; t.sign = MP_ZPOS; } digs = 0; while (mp_iszero (&t) == 0) { if ((res = mp_div_d (&t, (mp_digit) radix, &t, &d)) != MP_OKAY) { mp_clear (&t); return res; } *str++ = mp_s_rmap[d]; ++digs; } /* reverse the digits of the string. In this case _s points * to the first digit [exluding the sign] of the number] */ bn_reverse ((unsigned char *)_s, digs); /* append a NULL so the string is properly terminated */ *str = ’\0’; mp_clear (&t); return MP_OKAY; }
Chapter 9
Number Theoretic Algorithms This chapter discusses several fundamental number theoretic algorithms such as the greatest common divisor, least common multiple, and Jacobi symbol computation. These algorithms arise as essential components in several key cryptographic algorithms such as the RSA public key algorithm and various sieve–based factoring algorithms.
9.1
Greatest Common Divisor
The greatest common divisor of two integers a and b, often denoted as (a, b), is the largest integer k that is a proper divisor of both a and b. That is, k is the largest integer such that 0 ≡ a (mod k) and 0 ≡ b (mod k) occur simultaneously. The most common approach [1, pp. 337] is to reduce one operand modulo the other operand. That is, if a and b are divisible by some integer k and if qa + r = b, then r is also divisible by k. The reduction pattern follows ha, bi → hb, a mod bi.
255
256
www.syngress.com Algorithm Greatest Common Divisor (I). Input. Two positive integers a and b greater than zero. Output. The greatest common divisor (a, b). 1. While (b > 0) do 1.1 r ← a (mod b) 1.2 a ← b 1.3 b ← r 2. Return(a).
Figure 9.1: Algorithm Greatest Common Divisor (I) This algorithm will quickly converge on the greatest common divisor since the residue r tends to diminish rapidly (Figure 9.1). However, divisions are relatively expensive operations to perform and should ideally be avoided. There is another approach based on a similar relationship of greatest common divisors. The faster approach is based on the observation that if k divides both a and b, it will also divide a − b. In particular, we would like a − b to decrease in magnitude, which implies that b ≥ a. Algorithm Greatest Common Divisor (II). Input. Two positive integers a and b greater than zero. Output. The greatest common divisor (a, b). 1. While (b > 0) do 1.1 Swap a and b such that a is the smallest of the two. 1.2 b ← b − a 2. Return(a).
Figure 9.2: Algorithm Greatest Common Divisor (II) Theorem Algorithm 9.2 will return the greatest common divisor of a and b. Proof The algorithm in Figure 9.2 will eventually terminate; since b ≥ a the subtraction in step 1.2 will be a value less than b. In other words, in every iteration that tuple ha, bi, decrease in magnitude until eventually a = b. Since both a and b are always divisible by the greatest common divisor (until the last iteration) and in the last iteration of the algorithm b = 0, therefore, in the second to last iteration of the algorithm b = a and clearly (a, a) = a, which concludes the proof.
9.1 Greatest Common Divisor
257
QED As a matter of practicality, algorithm 9.1 decreases far too slowly to be useful, especially if b is much larger than a such that b − a is still very much larger than a. A simple addition to the algorithm is to divide b − a by a power of some integer p that does not divide the greatest common divisor but will divide b − a. In this case, b−a p is also an integer and still divisible by the greatest common divisor. However, instead of factoring b − a to find a suitable value of p, the powers of p can be removed from a and b that are in common first. Then, inside the loop whenever b − a is divisible by some power of p it can be safely removed. Algorithm Greatest Common Divisor (III). Input. Two positive integers a and b greater than zero. Output. The greatest common divisor (a, b). 1. k ← 0 2. While a and b are both divisible by p do 2.1 a ← ⌊a/p⌋ 2.2 b ← ⌊b/p⌋ 2.3 k ← k + 1 3. While a is divisible by p do 3.1 a ← ⌊a/p⌋ 4. While b is divisible by p do 4.1 b ← ⌊b/p⌋ 5. While (b > 0) do 5.1 Swap a and b such that a is the smallest of the two. 5.2 b ← b − a 5.3 While b is divisible by p do 5.3.1 b ← ⌊b/p⌋ 6. Return(a · pk ).
Figure 9.3: Algorithm Greatest Common Divisor (III) This algorithm is based on the first, except it removes powers of p first and inside the main loop to ensure the tuple ha, bi decreases more rapidly (Figure 9.3). The first loop in step 2 removes powers of p that are in common. A count, k, is kept that will present a common divisor of pk . After step 2 the remaining common
258
www.syngress.com
divisor of a and b cannot be divisible by p. This means that p can be safely divided out of the difference b − a as long as the division leaves no remainder. In particular, the value of p should be chosen such that the division in step 5.3.1 occurs often. It also helps that division by p be easy to compute. The ideal choice of p is two since division by two amounts to a right logical shift. Another important observation is that by step 5 both a and b are odd. Therefore, the difference b − a must be even, which means that each iteration removes one bit from the largest of the pair.
9.1.1
Complete Greatest Common Divisor
The algorithms presented so far cannot handle inputs that are zero or negative. The following algorithm can handle all input cases properly and will produce the greatest common divisor.
9.1 Greatest Common Divisor
259
Algorithm mp gcd. Input. mp int a and b Output. The greatest common divisor c = (a, b). 1. If a = 0 then 1.1 c ← |b| 1.2 Return(MP OKAY ). 2. If b = 0 then 2.1 c ← |a| 2.2 Return(MP OKAY ). 3. u ← |a|, v ← |b| 4. k ← 0 5. While u.used > 0 and v.used > 0 and u0 ≡ v0 ≡ 0 (mod 2) 5.1 k ← k + 1 5.2 u ← ⌊u/2⌋ 5.3 v ← ⌊v/2⌋ 6. While u.used > 0 and u0 ≡ 0 (mod 2) 6.1 u ← ⌊u/2⌋ 7. While v.used > 0 and v0 ≡ 0 (mod 2) 7.1 v ← ⌊v/2⌋ 8. While v.used > 0 8.1 If |u| > |v| then 8.1.1 Swap u and v. 8.2 v ← |v| − |u| 8.3 While v.used > 0 and v0 ≡ 0 (mod 2) 8.3.1 v ← ⌊v/2⌋ 9. c ← u · 2k 10. Return(MP OKAY ).
Figure 9.4: Algorithm mp gcd Algorithm mp gcd. This algorithm will produce the greatest common divisor of two mp ints a and b. It was originally based on Algorithm B, of Knuth [1, pp. 338] but has been modified to be simpler to explain. In theory, it achieves the same asymptotic working time as Algorithm B, and in practice, this appears to be true (Figure 9.4). The first two steps handle the cases where either one or both inputs are zero. If either input is zero, the greatest common divisor is the largest input or zero if they are both zero. If the inputs are not trivial, u and v are assigned the absolute
260
www.syngress.com
values of a and b, respectively, and the algorithm will proceed to reduce the pair. Step 5 will divide out any common factors of two and keep track of the count in the variable k. After this step, two is no longer a factor of the remaining greatest common divisor between u and v and can be safely evenly divided out of either whenever they are even. Steps 6 and 7 ensure that the u and v, respectively, have no more factors of two. At most, only one of the while loops will iterate since they cannot both be even. By step 8 both u and v are odd, which is required for the inner logic. First, the pair are swapped such that v is equal to or greater than u. This ensures that the subtraction in step 8.2 will always produce a positive and even result. Step 8.3 removes any factors of two from the difference u to ensure that in the next iteration of the loop both are again odd. After v = 0 occurs the variable u has the greatest common divisor of the pair hu, vi just after step 6. The result must be adjusted by multiplying by the common factors of two (2k ) removed earlier. File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040
bn mp gcd.c /* Greatest Common Divisor using the binary method */ int mp_gcd (mp_int * a, mp_int * b, mp_int * c) { mp_int u, v; int k, u_lsb, v_lsb, res; /* either zero then gcd is the largest */ if (mp_iszero (a) == MP_YES) { return mp_abs (b, c); } if (mp_iszero (b) == MP_YES) { return mp_abs (a, c); } /* get copies of a and b we can modify */ if ((res = mp_init_copy (&u, a)) != MP_OKAY) { return res; } if ((res = mp_init_copy (&v, b)) != MP_OKAY) { goto LBL_U; }
9.1 Greatest Common Divisor 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074 075 076 077 078 079 080 081
/* must be positive for the remainder of the algorithm */ u.sign = v.sign = MP_ZPOS; /* B1. u_lsb = v_lsb = k =
Find the common power of two for u and v */ mp_cnt_lsb(&u); mp_cnt_lsb(&v); MIN(u_lsb, v_lsb);
if (k > 0) { /* divide the power of two out */ if ((res = mp_div_2d(&u, k, &u, NULL)) != MP_OKAY) { goto LBL_V; } if ((res = mp_div_2d(&v, k, &v, NULL)) != MP_OKAY) { goto LBL_V; } } /* divide any remaining factors of two out */ if (u_lsb != k) { if ((res = mp_div_2d(&u, u_lsb - k, &u, NULL)) != MP_OKAY) { goto LBL_V; } } if (v_lsb != k) { if ((res = mp_div_2d(&v, v_lsb - k, &v, NULL)) != MP_OKAY) { goto LBL_V; } } while (mp_iszero(&v) == 0) { /* make sure v is the largest */ if (mp_cmp_mag(&u, &v) == MP_GT) { /* swap u and v to make sure v is >= u */ mp_exch(&u, &v); } /* subtract smallest from largest */ if ((res = s_mp_sub(&v, &u, &v)) != MP_OKAY) {
261
262 082 083 084 085 086 087 088 089 090 091 092 093 094 095 096 097 098 099 100 101
www.syngress.com goto LBL_V; } /* Divide out all factors of two */ if ((res = mp_div_2d(&v, mp_cnt_lsb(&v), &v, NULL)) != MP_OKAY) { goto LBL_V; } } /* multiply by 2**k which we divided out at the beginning */ if ((res = mp_mul_2d (&u, k, c)) != MP_OKAY) { goto LBL_V; } c->sign = MP_ZPOS; res = MP_OKAY; LBL_V:mp_clear (&u); LBL_U:mp_clear (&v); return res; }
This function makes use of the macros mp iszero and mp iseven. The former evaluates to 1 if the input mp int is equivalent to the integer zero; otherwise, it evaluates to 0. The latter evaluates to 1 if the input mp int represents a non-zero even integer; otherwise, it evaluates to 0. Note that just because mp iseven may evaluate to 0 does not mean the input is odd; it could also be zero. The three trivial cases of inputs are handled on lines 24 through 30. After those lines, the inputs are assumed non-zero. Lines 32 and 37 make local copies u and v of the inputs a and b respectively. At this point, the common factors of two must be divided out of the two inputs. The block starting at line 44 removes common factors of two by first counting the number of trailing zero bits in both. The local integer k is used to keep track of how many factors of 2 are pulled out of both values. It is assumed that the number of factors will not exceed the maximum value of a C “int” data type1 . At this point, there are no more common factors of two in the two values. The divisions by a power of two on lines 62 and 68 remove any independent factors of two such that both u and v are guaranteed to be an odd integer before hitting the 1 Strictly speaking, no array in C may have more than entries than are accessible by an “int” so this is not a limitation.
9.2 Least Common Multiple
263
main body of the algorithm. The while loop on line 73 performs the reduction of the pair until v is equal to zero. The unsigned comparison and subtraction algorithms are used in place of the full signed routines since both values are guaranteed to be positive and the result of the subtraction is guaranteed to be non-negative.
9.2
Least Common Multiple
The least common multiple of a pair of integers is their product divided by their greatest common divisor. For two integers a and b the least common multiple ab . For example, is normally denoted as [a, b] and numerically equivalent to (a,b) if a = 2 · 2 · 3 = 12 and b = 2 · 3 · 3 · 7 = 126, the least common multiple is 126 126 (12,126) = 6 = 21. The least common multiple arises often in coding theory and number theory. If two functions have periods of a and b, respectively, they will collide, that is be in synchronous states, after only [a, b] iterations. This is why, for example, random number generators based on Linear Feedback Shift Registers (LFSR) tend to use registers with periods that are co-prime (e.g., the greatest common divisor is 1.). Similarly, in number theory if a composite n has two prime factors p and q, then maximal order of any unit of Z/nZ will be [p − 1, q − 1]. Algorithm mp lcm. Input. mp int a and b Output. The least common multiple c = [a, b]. 1. 2. 3. 4.
c ← (a, b) t ← a·b c ← ⌊t/c⌋ Return(MP OKAY ).
Figure 9.5: Algorithm mp lcm Algorithm mp lcm. This algorithm computes the least common multiple of two mp int inputs a and b. It computes the least common multiple directly by dividing the product of the two inputs by their greatest common divisor (Figure 9.5).
264 File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056
www.syngress.com bn mp lcm.c /* computes least common multiple as |a*b|/(a, b) */ int mp_lcm (mp_int * a, mp_int * b, mp_int * c) { int res; mp_int t1, t2;
if ((res = mp_init_multi (&t1, &t2, NULL)) != MP_OKAY) { return res; } /* t1 = get the GCD of the two inputs */ if ((res = mp_gcd (a, b, &t1)) != MP_OKAY) { goto LBL_T; } /* divide the smallest by the GCD */ if (mp_cmp_mag(a, b) == MP_LT) { /* store quotient in t2 such that t2 * b if ((res = mp_div(a, &t1, &t2, NULL)) != goto LBL_T; } res = mp_mul(b, &t2, c); } else { /* store quotient in t2 such that t2 * a if ((res = mp_div(b, &t1, &t2, NULL)) != goto LBL_T; } res = mp_mul(a, &t2, c); } /* fix the sign to positive */ c->sign = MP_ZPOS; LBL_T: mp_clear_multi (&t1, &t2, NULL); return res; }
is the LCM */ MP_OKAY) {
is the LCM */ MP_OKAY) {
265
9.3 Jacobi Symbol Computation
9.3
Jacobi Symbol Computation
To explain the Jacobi Symbol we will first discuss the Legendre function off which the Jacobi symbol is defined. The Legendre function computes whether an integer a is a quadratic residue modulo an odd prime p. Numerically it is equivalent to equation 9.1. a(p−1)/2 ≡
−1 if a is a quadratic non-residue. 0 if a divides p. (mod p) 1 if a is a quadratic residue.
(9.1)
Theorem. Equation 9.1 correctly identifies the residue status of an integer a modulo a prime p. Proof. Adapted from [21, pp. 68]. An integer a is a quadratic residue if the following equation has a solution. x2 ≡ a (mod p)
(9.2)
Consider the following equation. 0 ≡ xp−1 − 1 ≡
n
x2
(p−1)/2
o − a(p−1)/2 + a(p−1)/2 − 1 (mod p)
(9.3)
Whether equation 9.2 has a solution or not, equation 9.3 is always true. If a(p−1)/2 − 1 ≡ 0 (mod p), then the quantity in the braces must be zero. By reduction, x2
(p−1)/2 x2
− a(p−1)/2 ≡ 0
(p−1)/2
≡ a(p−1)/2
x2 ≡ a (mod p)
(9.4)
As a result there must be a solution to the quadratic equation, and in turn, a must be a quadratic residue. If a does not divide p and a is not a quadratic residue, then the only other value a(p−1)/2 may be congruent to is −1 since 0 ≡ ap−1 − 1 ≡ (a(p−1)/2 + 1)(a(p−1)/2 − 1) (mod p) One of the terms on the right-hand side must be zero.
(9.5)
266
www.syngress.com
QED
9.3.1
Jacobi Symbol
The Jacobi symbol is a generalization of the Legendre function for any odd non– Q prime moduli p greater than 2. If p = ni=0 pi , then the Jacobi symbol ap is equal to the following equation. a a a a ... (9.6) = p p0 p1 pn By inspection if p is prime, the Jacobi symbol is equivalent to the Legendre function. The following facts2 will be used to derive an efficient Jacobi symbol algorithm. Where p is an odd integer greater than two and a, b ∈ Z, the following are true. 1. ap equals −1, 0 or 1. 2.
ab p
=
a p
b p
3. If a ≡ b then
.
a p
=
b p
.
4.
equals 1 if p ≡ 1 or 7 (mod 8). Otherwise, it equals −1.
5.
≡
2 p
a p
p a
1 (mod 4).
· (−1)(p−1)(a−1)/4 . More specifically,
a p
=
p a
if p ≡ a ≡
Using these facts if a = 2k · a′ then k ′ 2 a a = p p p k ′ 2 a = p p By fact five, 2 See
HAC [2, pp. 72-74] for further details.
(9.7)
9.3 Jacobi Symbol Computation
a p = · (−1)(p−1)(a−1)/4 p a Subsequently, by fact three since p ≡ (p mod a) (mod a), then p mod a a = · (−1)(p−1)(a−1)/4 p a
267
(9.8)
(9.9)
By putting both observations into equation 9.7, the following simplified equation is formed. k ′ a 2 p mod a′ · (−1)(p−1)(a −1)/4 (9.10) = p p a′ a′ can be found using the same equation recursively. The value of p mod a′ k equals 1 if k is even; otherwise, it equals 2p . Using this The value of 2p approach the factors of p do not have to be known. Furthermore, if (a, p) = 1, then the algorithm will terminate when the recursion requests the Jacobi symbol computation of a1′ , which is simply 1.
268
www.syngress.com Algorithm mp jacobi. Input. mp int a and p, a ≥ 0, p ≥ “ 3,”p ≡ 1 (mod 2) Output. The Jacobi symbol c = ap . 1. If a = 0 then 1.1 c ← 0 1.2 Return(MP OKAY ). 2. If a = 1 then 2.1 c ← 1 2.2 Return(MP OKAY ). 3. a′ ← a 4. k ← 0 5. While a′ .used > 0 and a′0 ≡ 0 (mod 2) 5.1 k ← k + 1 5.2 a′ ← ⌊a′ /2⌋ 6. If k ≡ 0 (mod 2) then 6.1 s ← 1 7. else 7.1 r ← p0 (mod 8) 7.2 If r = 1 or r = 7 then 7.2.1 s ← 1 7.3 else 7.3.1 s ← −1 8. If p0 ≡ a′0 ≡ 3 (mod 4) then 8.1 s ← −s 9. If a′ 6= 1 then 9.1 p′ ← p (mod a′ ) 9.2 s ← s · mp jacobi(p′ , a′ ) 10. c ← s 11. Return(MP OKAY ).
Figure 9.6: Algorithm mp jacobi Algorithm mp jacobi. This algorithm computes the Jacobi symbol for an arbitrary positive integer a with respect to an odd integer p greater than three. The algorithm is based on algorithm 2.149 of HAC [2, pp. 73] (Figure 9.6). Steps 1 and 2 handle the trivial cases of a = 0 and a = 1, respectively. Step 5 determines the number of two factors in the input a. If k is even, the term k 2 must always evaluate to one. If k is odd, the term evaluates to one if p0 is p
9.3 Jacobi Symbol Computation
269
congruent to one or seven modulo eight; otherwise, it evaluates to −1. After the k ′ 2 term is handled, the (−1)(p−1)(a −1)/4 is computed and multiplied against p the current product s. The latter term evaluates to one if both p and a′ are congruent to one modulo four; otherwise, it evaluates to negative one. By step 9 if a′ does not equal one a recursion ′ is required. Step 9.1 computes ′ ′ p ≡ p (mod a ) and will recurse to compute ap′ , which is multiplied against the current Jacobi product. File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048
bn mp jacobi.c /* computes the jacobi c = (a | n) (or Legendre if n is prime) * HAC pp. 73 Algorithm 2.149 */ int mp_jacobi (mp_int * a, mp_int * p, int *c) { mp_int a1, p1; int k, s, r, res; mp_digit residue; /* if p dp[0] & 7; if (residue == 1 || residue == 7) { s = 1; } else if (residue == 3 || residue == 5) { s = -1; } } /* step 5. if p == 3 (mod 4) *and* a1 == 3 (mod 4) then s = -s */ if ( ((p->dp[0] & 3) == 3) && ((a1.dp[0] & 3) == 3)) { s = -s; } /* if a1 == 1 we’re done */ if (mp_cmp_d (&a1, 1) == MP_EQ) { *c = s; } else { /* n1 = n mod a1 */ if ((res = mp_mod (p, &a1, &p1)) != MP_OKAY) { goto LBL_P1; } if ((res = mp_jacobi (&p1, &a1, &r)) != MP_OKAY) {
9.4 Modular Inverse 090 091 092 093 094 095 096 097 098 099 100 101
271
goto LBL_P1; } *c = s * r; } /* done */ res = MP_OKAY; LBL_P1:mp_clear (&p1); LBL_A1:mp_clear (&a1); return res; }
As a matter of practicality the variable a′ as per the pseudo-code is represented by the variable a1 since the ′ symbol is not valid for a C variable name character. The two simple cases of a = 0 and a = 1 are handled at the very beginning to simplify the algorithm. If the input is non-trivial, the algorithm has to proceed and compute the Jacobi. The variable s is used to hold the current Jacobi product. Note that s is merely a C “int” data type since the values it may obtain are merely −1, 0 and 1. After a local copy of a is made, all the factors of two are divided out and the total stored in k. Technically, only the least significant bit of k is required; however, it makes the algorithm simpler to follow to perform an addition. In practice, an exclusive-or and addition have the same processor requirements, and neither is faster than the other. k Lines 62 through 73 determine the value of p2 . If the least significant bit of k is zero, then k is even and the value is one. Otherwise, the value of s depends ′ on which residue class p belongs to modulo eight. The value of (−1)(p−1)(a −1)/4 is computed and multiplied against s on lines 76 through 91. if a1 does not equal one, the algorithm must recurse and compute ′ Finally, p a′ .
9.4
Modular Inverse
The modular inverse of a number refers to the modular multiplicative inverse. For any integer a such that (a, p) = 1 there exists another integer b such that ab ≡ 1 (mod p). The integer b is called the multiplicative inverse of a which is denoted as b = a−1 . Modular inversion is a well–defined operation for any finite
272
www.syngress.com
ring or field, not just for rings and fields of integers. However, the former will be the matter of discussion. The simplest approach is to compute the algebraic inverse of the input; that is, to compute b ≡ aΦ(p)−1 . If Φ(p) is the order of the multiplicative subgroup modulo p, then b must be the multiplicative inverse of a–the proof of which is trivial. ab ≡ a aΦ(p)−1 ≡ aΦ(p) ≡ a0 ≡ 1 (mod p) (9.11) However, as simple as this approach may be it has two serious flaws. It requires that the value of Φ(p) be known, which if p is composite requires all of the prime factors. This approach also is very slow as the size of p grows. A simpler approach is based on the observation that solving for the multiplicative inverse is equivalent to solving the linear Diophantine3 equation. ab + pq = 1
(9.12)
Where a, b, p, and q are all integers. If such a pair of integers hb, qi exists, b is the multiplicative inverse of a modulo p. The extended Euclidean algorithm (Knuth [1, pp. 342]) can be used to solve such equations provided (a, p) = 1. However, instead of using that algorithm directly, a variant known as the binary Extended Euclidean algorithm will be used in its place. The binary approach is very similar to the binary greatest common divisor algorithm, except it will produce a full solution to the Diophantine equation.
3 See
LeVeque [21, pp. 40-43] for more information.
9.4 Modular Inverse
9.4.1
273
General Case
Algorithm mp invmod. Input. mp int a and b, (a, b) = 1, p ≥ 2, 0 < a < p. Output. The modular inverse c ≡ a−1 (mod b). 1. 2. 3. 4. 5. 6.
If b ≤ 0 then return(MP VAL). If b0 ≡ 1 (mod 2) then use algorithm fast mp invmod. x ← |a|, y ← b If x0 ≡ y0 ≡ 0 (mod 2) then return(MP VAL). B ← 0, C ← 0, A ← 1, D ← 1 While u.used > 0 and u0 ≡ 0 (mod 2) 6.1 u ← ⌊u/2⌋ 6.2 If (A.used > 0 and A0 ≡ 1 (mod 2)) or (B.used > 0 and B0 ≡ 1 (mod 2)) then 6.2.1 A ← A + y 6.2.2 B ← B − x 6.3 A ← ⌊A/2⌋ 6.4 B ← ⌊B/2⌋ 7. While v.used > 0 and v0 ≡ 0 (mod 2) 7.1 v ← ⌊v/2⌋ 7.2 If (C.used > 0 and C0 ≡ 1 (mod 2)) or (D.used > 0 and D0 ≡ 1 (mod 2)) then 7.2.1 C ← C + y 7.2.2 D ← D − x 7.3 C ← ⌊C/2⌋ 7.4 D ← ⌊D/2⌋ 8. If u ≥ v then 8.1 u ← u − v 8.2 A ← A − C 8.3 B ← B − D 9. else 9.1 v ← v − u 9.2 C ← C − A 9.3 D ← D − B Continued on the next page.
274
www.syngress.com Algorithm mp invmod (continued). Input. mp int a and b, (a, b) = 1, p ≥ 2, 0 < a < p. Output. The modular inverse c ≡ a−1 (mod b). 10. If u 6= 0 goto step 6. 11. If v 6= 1 return(MP VAL). 12. While C ≤ 0 do 12.1 C ← C + b 13. While C ≥ b do 13.1 C ← C − b 14. c ← C 15. Return(MP OKAY ).
Figure 9.7: Algorithm mp invmod Algorithm mp invmod. This algorithm computes the modular multiplicative inverse of an integer a modulo an integer b. It is a variation of the extended binary Euclidean algorithm from HAC [2, pp. 608], and it has been modified to only compute the modular inverse and not a complete Diophantine solution (Figure 9.7). If b ≤ 0, the modulus is invalid and MP VAL is returned. Similarly if both a and b are even, there cannot be a multiplicative inverse for a and the error is reported. The astute reader will observe that steps 7 through 9 are very similar to the binary greatest common divisor algorithm mp gcd. In this case, the other variables to the Diophantine equation are solved. The algorithm terminates when u = 0, in which case the solution is Ca + Db = v
(9.13)
If v, the greatest common divisor of a and b, is not equal to one, then the algorithm will report an error as no inverse exists. Otherwise, C is the modular inverse of a. The actual value of C is congruent to, but not necessarily equal to, the ideal modular inverse, which should lie within 1 ≤ a−1 < b. Steps 12 and 13 adjust the inverse until it is in range. If the original input a is within 0 < a < p, then only a couple of additions or subtractions will be required to adjust the inverse.
9.4 Modular Inverse File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039
275
bn mp invmod.c /* hac 14.61, pp608 */ int mp_invmod (mp_int * a, mp_int * b, mp_int * c) { /* b cannot be negative */ if (b->sign == MP_NEG || mp_iszero(b) == 1) { return MP_VAL; } #ifdef BN_FAST_MP_INVMOD_C /* if the modulus is odd we can use a faster routine instead */ if (mp_isodd (b) == 1) { return fast_mp_invmod (a, b, c); } #endif #ifdef BN_MP_INVMOD_SLOW_C return mp_invmod_slow(a, b, c); #endif return MP_VAL; }
Odd Moduli When the modulus b is odd the variables A and C are fixed and are not required to compute the inverse. In particular, by attempting to solve the Diophantine Cb + Da = 1, only B and D are required to find the inverse of a. The algorithm fast mp invmod is a direct adaptation of algorithm mp invmod with all steps involving either A or C removed. This optimization will halve the time required to compute the modular inverse. File: bn fast mp invmod.c 018 /* computes the modular inverse via binary extended euclidean algorithm, 019 * that is c = 1/a mod b 020 * 021 * Based on slow invmod except this is optimized for the case where b is 022 * odd as per HAC Note 14.64 on pp. 610 023 */ 024 int fast_mp_invmod (mp_int * a, mp_int * b, mp_int * c)
276 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065
www.syngress.com { mp_int int
x, y, u, v, B, D; res, neg;
/* 2. [modified] b must be odd if (mp_iseven (b) == 1) { return MP_VAL; }
*/
/* init all our temps */ if ((res = mp_init_multi(&x, &y, &u, &v, &B, &D, NULL)) != MP_OKAY) { return res; } /* x == modulus, y == value to invert */ if ((res = mp_copy (b, &x)) != MP_OKAY) { goto LBL_ERR; } /* we need y = |a| */ if ((res = mp_mod (a, b, &y)) != MP_OKAY) { goto LBL_ERR; } /* 3. u=x, v=y, A=1, B=0, C=0,D=1 */ if ((res = mp_copy (&x, &u)) != MP_OKAY) { goto LBL_ERR; } if ((res = mp_copy (&y, &v)) != MP_OKAY) { goto LBL_ERR; } mp_set (&D, 1); top: /* 4. while u is even do */ while (mp_iseven (&u) == 1) { /* 4.1 u = u/2 */ if ((res = mp_div_2 (&u, &u)) != MP_OKAY) { goto LBL_ERR; } /* 4.2 if B is odd then */
9.4 Modular Inverse 066 067 068 069 070 071 072 073 074 075 076 077 078 079 080 081 082 083 084 085 086 087 088 089 090 091 092 093 094 095 096 097 098 099 100 101 102 103 104 105 106
if (mp_isodd (&B) == 1) { if ((res = mp_sub (&B, &x, &B)) != MP_OKAY) { goto LBL_ERR; } } /* B = B/2 */ if ((res = mp_div_2 (&B, &B)) != MP_OKAY) { goto LBL_ERR; } } /* 5. while v is even do */ while (mp_iseven (&v) == 1) { /* 5.1 v = v/2 */ if ((res = mp_div_2 (&v, &v)) != MP_OKAY) { goto LBL_ERR; } /* 5.2 if D is odd then */ if (mp_isodd (&D) == 1) { /* D = (D-x)/2 */ if ((res = mp_sub (&D, &x, &D)) != MP_OKAY) { goto LBL_ERR; } } /* D = D/2 */ if ((res = mp_div_2 (&D, &D)) != MP_OKAY) { goto LBL_ERR; } } /* 6. if u >= v then */ if (mp_cmp (&u, &v) != MP_LT) { /* u = u - v, B = B - D */ if ((res = mp_sub (&u, &v, &u)) != MP_OKAY) { goto LBL_ERR; } if ((res = mp_sub (&B, &D, &B)) != MP_OKAY) { goto LBL_ERR; } } else {
277
278 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
www.syngress.com /* v - v - u, D = D - B */ if ((res = mp_sub (&v, &u, &v)) != MP_OKAY) { goto LBL_ERR; } if ((res = mp_sub (&D, &B, &D)) != MP_OKAY) { goto LBL_ERR; } } /* if not zero goto step 4 */ if (mp_iszero (&u) == 0) { goto top; } /* now a = C, b = D, gcd == g*v */ /* if v != 1 then there is no inverse */ if (mp_cmp_d (&v, 1) != MP_EQ) { res = MP_VAL; goto LBL_ERR; } /* b is now the inverse */ neg = a->sign; while (D.sign == MP_NEG) { if ((res = mp_add (&D, b, &D)) != MP_OKAY) { goto LBL_ERR; } } mp_exch (&D, c); c->sign = neg; res = MP_OKAY; LBL_ERR:mp_clear_multi (&x, &y, &u, &v, &B, &D, NULL); return res; }
9.5 Primality Tests
9.5
279
Primality Tests
A non-zero integer a is said to be prime if it is not divisible by any other integer excluding one and itself. For example, a = 7 is prime since the integers 2 . . . 6 do not evenly divide a. By contrast, a = 6 is not prime since a = 6 = 2 · 3. Prime numbers arise in cryptography considerably as they allow finite fields to be formed. The ability to determine whether an integer is prime quickly has been a viable subject in cryptography and number theory for considerable time. The algorithms that will be presented are all probabilistic algorithms in that when they report an integer is composite it must be composite. However, when the algorithms report an integer is prime the algorithm may be incorrect. As will be discussed, it is possible to limit the probability of error so well that for practical purposes the probability of error might as well be zero. For the purposes of these discussions, let n represent the candidate integer of which the primality is in question.
9.5.1
Trial Division
Trial division means to attempt to evenly divide a candidate integer by small prime integers. If the candidate can be evenly divided, it obviously cannot be prime. √ By dividing by all primes 1 < p ≤ n, this test can actually prove whether an integer is prime. However, such a test would require a prohibitive amount of time as n grows. Instead of dividing by every prime, a smaller, more manageable set of primes may be used √ instead. By performing trial division with only a subset of the primes less than n + 1, the algorithm cannot prove if a candidate is prime. However, often it can prove a candidate is not prime. The benefit of this test is that trial division by small values is fairly efficient, especially when compared to the other algorithms that will be discussed shortly. The probability that this approach correctly identifies a composite candidate when 1.12 . tested with all primes up to q is given by 1 − ln(q) At approximately q = 30 the gain of performing further tests diminishes fairly quickly. At q = 90, further testing is generally not going to be of any practical use. In the case of LibTomMath the default limit q = 256 was chosen since it is not too high and will eliminate approximately 80% of all candidate integers. The constant PRIME SIZE is equal to the number of primes in the test base. The array prime tab is an array of the first PRIME SIZE prime numbers.
280
www.syngress.com Algorithm mp prime is divisible. Input. mp int a Output. c = 1 if n is divisible by a small prime, otherwise c = 0. 1. for ix from 0 to P RIM E SIZE do 1.1 d ← n (mod prime tabix ) 1.2 If d = 0 then 1.2.1 c ← 1 1.2.2 Return(MP OKAY ). 2. c ← 0 3. Return(MP OKAY ).
Figure 9.8: Algorithm mp prime is divisible Algorithm mp prime is divisible. This algorithm attempts to determine if a candidate integer n is composite by performing trial divisions (Figure 9.8). File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040
bn mp prime is divisible.c /* determines if an integers is divisible by one * of the first PRIME_SIZE primes or not * * sets result to 0 if not, 1 if yes */ int mp_prime_is_divisible (mp_int * a, int *result) { int err, ix; mp_digit res; /* default to not */ *result = MP_NO; for (ix = 0; ix < PRIME_SIZE; ix++) { /* what is a mod LBL_prime_tab[ix] */ if ((err = mp_mod_d (a, ltm_prime_tab[ix], &res)) != MP_OKAY) { return err; } /* is the residue zero? */ if (res == 0) { *result = MP_YES; return MP_OKAY;
9.5 Primality Tests 041 042 043 044 045 046
281
} } return MP_OKAY; }
The algorithm defaults to a return of 0 in case an error occurs. The values in the prime table are all specified to be in the range of an mp digit. The table prime tab is defined in the following file. File: bn prime tab.c 017 const mp_digit ltm_prime_tab[] = { 018 0x0002, 0x0003, 0x0005, 0x0007, 0x000B, 0x000D, 0x0011, 0x0013, 019 0x0017, 0x001D, 0x001F, 0x0025, 0x0029, 0x002B, 0x002F, 0x0035, 020 0x003B, 0x003D, 0x0043, 0x0047, 0x0049, 0x004F, 0x0053, 0x0059, 021 0x0061, 0x0065, 0x0067, 0x006B, 0x006D, 0x0071, 0x007F, 022 #ifndef MP_8BIT 023 0x0083, 024 0x0089, 0x008B, 0x0095, 0x0097, 0x009D, 0x00A3, 0x00A7, 0x00AD, 025 0x00B3, 0x00B5, 0x00BF, 0x00C1, 0x00C5, 0x00C7, 0x00D3, 0x00DF, 026 0x00E3, 0x00E5, 0x00E9, 0x00EF, 0x00F1, 0x00FB, 0x0101, 0x0107, 027 0x010D, 0x010F, 0x0115, 0x0119, 0x011B, 0x0125, 0x0133, 0x0137, 028 029 0x0139, 0x013D, 0x014B, 0x0151, 0x015B, 0x015D, 0x0161, 0x0167, 030 0x016F, 0x0175, 0x017B, 0x017F, 0x0185, 0x018D, 0x0191, 0x0199, 031 0x01A3, 0x01A5, 0x01AF, 0x01B1, 0x01B7, 0x01BB, 0x01C1, 0x01C9, 032 0x01CD, 0x01CF, 0x01D3, 0x01DF, 0x01E7, 0x01EB, 0x01F3, 0x01F7, 033 0x01FD, 0x0209, 0x020B, 0x021D, 0x0223, 0x022D, 0x0233, 0x0239, 034 0x023B, 0x0241, 0x024B, 0x0251, 0x0257, 0x0259, 0x025F, 0x0265, 035 0x0269, 0x026B, 0x0277, 0x0281, 0x0283, 0x0287, 0x028D, 0x0293, 036 0x0295, 0x02A1, 0x02A5, 0x02AB, 0x02B3, 0x02BD, 0x02C5, 0x02CF, 037 038 0x02D7, 0x02DD, 0x02E3, 0x02E7, 0x02EF, 0x02F5, 0x02F9, 0x0301, 039 0x0305, 0x0313, 0x031D, 0x0329, 0x032B, 0x0335, 0x0337, 0x033B, 040 0x033D, 0x0347, 0x0355, 0x0359, 0x035B, 0x035F, 0x036D, 0x0371, 041 0x0373, 0x0377, 0x038B, 0x038F, 0x0397, 0x03A1, 0x03A9, 0x03AD, 042 0x03B3, 0x03B9, 0x03C7, 0x03CB, 0x03D1, 0x03D7, 0x03DF, 0x03E5, 043 0x03F1, 0x03F5, 0x03FB, 0x03FD, 0x0407, 0x0409, 0x040F, 0x0419, 044 0x041B, 0x0425, 0x0427, 0x042D, 0x043F, 0x0443, 0x0445, 0x0449, 045 0x044F, 0x0455, 0x045D, 0x0463, 0x0469, 0x047F, 0x0481, 0x048B,
282 046 047 048 049 050 051 052 053 054 055 056 057
www.syngress.com
0x0493, 0x04CD, 0x0509, 0x052F, 0x0593, 0x05BF, 0x05F3, 0x062B, #endif };
0x049D, 0x04CF, 0x050B, 0x0551, 0x0595, 0x05C9, 0x05FB, 0x062F,
0x04A3, 0x04D5, 0x0511, 0x0557, 0x0599, 0x05CB, 0x0607, 0x063D,
0x04A9, 0x04E1, 0x0515, 0x055D, 0x059F, 0x05CF, 0x060D, 0x0641,
0x04B1, 0x04EB, 0x0517, 0x0565, 0x05A7, 0x05D1, 0x0611, 0x0647,
0x04BD, 0x04FD, 0x051B, 0x0577, 0x05AB, 0x05D5, 0x0617, 0x0649,
0x04C1, 0x04FF, 0x0527, 0x0581, 0x05AD, 0x05DB, 0x061F, 0x064D,
0x04C7, 0x0503, 0x0529, 0x058F, 0x05B3, 0x05E7, 0x0623, 0x0653
Note that there are two possible tables. When an mp digit is 7-bits long, only the primes up to 127 may be included; otherwise, the primes up to 1619 are used. Note that the value of PRIME SIZE is a constant dependent on the size of a mp digit.
9.5.2
The Fermat Test
The Fermat test is probably one the oldest tests to have a non-trivial probability of success. It is based on the fact that if n is in fact prime, then an ≡ a (mod n) for all 0 < a < n. The reason being that if n is prime, the order of the multiplicative subgroup is n − 1. Any base a must have an order that divides n − 1, and as such, an is equivalent to a1 = a. If n is composite then any given base a does not have to have a period that divides n − 1, in which case it is possible that an 6≡ a (mod n). However, this test is not absolute as it is possible that the order of a base will divide n − 1, which would then be reported as prime. Such a base yields what is known as a Fermat pseudo-prime. Several integers known as Carmichael numbers will be a pseudo-prime to all valid bases. Fortunately, such numbers are extremely rare as n grows in size.
283
9.5 Primality Tests Algorithm mp prime fermat. Input. mp int a and b, a ≥ 2, 0 < b < a. Output. c = 1 if ba ≡ b (mod a), otherwise c = 0. 1. t ← ba (mod a) 2. If t = b then 2.1 c = 1 3. else 3.1 c = 0 4. Return(MP OKAY ).
Figure 9.9: Algorithm mp prime fermat Algorithm mp prime fermat. This algorithm determines whether an mp int a is a Fermat prime to the base b or not. It uses a single modular exponentiation to determine the result (Figure 9.9). File: 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039
bn mp prime fermat.c /* performs one Fermat test. * * If "a" were prime then b**a == b (mod a) since the order of * the multiplicative sub-group would be phi(a) = a-1. That means * it would be the same as b**(a mod (a-1)) == b**1 == b (mod a). * * Sets result to 1 if the congruence holds, or zero otherwise. */ int mp_prime_fermat (mp_int * a, mp_int * b, int *result) { mp_int t; int err; /* default to composite *result = MP_NO;
*/
/* ensure b > 1 */ if (mp_cmp_d(b, 1) != MP_GT) { return MP_VAL; } /* init t */
284 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058
9.5.3
www.syngress.com if ((err = mp_init (&t)) != MP_OKAY) { return err; } /* compute t = b**a mod a */ if ((err = mp_exptmod (b, a, a, &t)) != MP_OKAY) { goto LBL_T; } /* is it equal to b? */ if (mp_cmp (&t, b) == MP_EQ) { *result = MP_YES; } err = MP_OKAY; LBL_T:mp_clear (&t); return err; }
The Miller-Rabin Test
The Miller-Rabin test is another primality test that has tighter error bounds than the Fermat test specifically with sequentially chosen candidate integers. The algorithm is based on the observation that if n − 1 = 2k r and if br 6≡ ±1, then after up to k − 1 squarings the value must be equal to −1. The squarings are stopped as soon as −1 is observed. If the value of 1 is observed first, it means that some value not congruent to ±1 when squared equals one, which cannot occur if n is prime.
9.5 Primality Tests
285
Algorithm mp prime miller rabin. Input. mp int a and b, a ≥ 2, 0 < b < a. Output. c = 1 if a is a Miller-Rabin prime to the base a, otherwise c = 0. 1. a′ ← a − 1 2. r ← n1 3. c ← 0, s ← 0 4. While r.used > 0 and r0 ≡ 0 (mod 2) 4.1 s ← s + 1 4.2 r ← ⌊r/2⌋ 5. y ← br (mod a) 6. If y 6≡ ±1 then 6.1 j ← 1 6.2 While j ≤ (s − 1) and y 6≡ a′ 6.2.1 y ← y 2 (mod a) 6.2.2 If y = 1 then goto step 8. 6.2.3 j ← j + 1 6.3 If y 6≡ a′ goto step 8. 7. c ← 1 8. Return(MP OKAY ).
Figure 9.10: Algorithm mp prime miller rabin Algorithm mp prime miller rabin. This algorithm performs one trial round of the Miller-Rabin algorithm to the base b. It will set c = 1 if the algorithm cannot determine if b is composite or c = 0 if b is provably composite. The values of s and r are computed such that a′ = a − 1 = 2s r (Figure 9.10). If the value y ≡ br is congruent to ±1, then the algorithm cannot prove if a is composite or not. Otherwise, the algorithm will square y up to s − 1 times stopping only when y ≡ −1. If y 2 ≡ 1 and y 6≡ ±1, then the algorithm can report that a is provably composite. If the algorithm performs s − 1 squarings and y 6≡ −1, then a is provably composite. If a is not provably composite, then it is probably prime. File: bn mp prime miller rabin.c 018 /* Miller-Rabin test of "a" to the base of "b" as described in 019 * HAC pp. 139 Algorithm 4.24 020 * 021 * Sets result to 0 if definitely composite or 1 if probably prime. 022 * Randomly the chance of error is no more than 1/4 and often 023 * very much lower.
286 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064
www.syngress.com */ int mp_prime_miller_rabin (mp_int * a, mp_int * b, int *result) { mp_int n1, y, r; int s, j, err; /* default */ *result = MP_NO; /* ensure b > 1 */ if (mp_cmp_d(b, 1) != MP_GT) { return MP_VAL; } /* get n1 = a - 1 */ if ((err = mp_init_copy (&n1, a)) != MP_OKAY) { return err; } if ((err = mp_sub_d (&n1, 1, &n1)) != MP_OKAY) { goto LBL_N1; } /* set 2**s * r = n1 */ if ((err = mp_init_copy (&r, &n1)) != MP_OKAY) { goto LBL_N1; } /* count the number of least significant bits * which are zero */ s = mp_cnt_lsb(&r); /* now divide n - 1 by 2**s */ if ((err = mp_div_2d (&r, s, &r, NULL)) != MP_OKAY) { goto LBL_R; } /* compute y = b**r mod a */ if ((err = mp_init (&y)) != MP_OKAY) { goto LBL_R; }
9.5 Primality Tests 065 066 067 068 069 070 071 072 073 074 075 076 077 078 079 080 081 082 083 084 085 086 087 088 089 090 091 092 093 094 095 096 097 098 099
if ((err = mp_exptmod (b, &r, a, &y)) != MP_OKAY) { goto LBL_Y; } /* if y != 1 and y != n1 do */ if (mp_cmp_d (&y, 1) != MP_EQ && mp_cmp (&y, &n1) != MP_EQ) { j = 1; /* while j
