Skip to content

Commit bc499dd

Browse files
TilmanNeumannTilmanNeumann
committed
check factoring argument bounds
1 parent d5b5641 commit bc499dd

4 files changed

+99
-80
lines changed

‎src/main/java/de/tilman_neumann/jml/factor/pollardRho/PollardRhoBrentMontgomery64.java

+25-20
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@ public class PollardRhoBrentMontgomery64 extends FactorAlgorithm {
5151
// The reducer R is 2^64, but the only constant still required is the half of it.
5252
private static final long R_HALF = 1L << 63;
5353

54-
private long N;
54+
private long n;
5555

5656
private long minusNInvModR; // (-1/N) mod R, required for Montgomery multiplication
5757

@@ -64,61 +64,66 @@ public String getName() {
6464

6565
@Override
6666
public BigInteger findSingleFactor(BigInteger N) {
67-
return BigInteger.valueOf(findSingleFactor(N.longValue()));
67+
if (N.bitLength() > 63) { // this check should be negligible in terms of performance
68+
throw new IllegalArgumentException("N = " + N + " has " + N.bitLength() + " bit, but " + getName() + " only supports arguments <= 63 bit");
69+
}
70+
long factorLong = findSingleFactor(N.longValue());
71+
return BigInteger.valueOf(factorLong);
6872
}
6973

70-
public long findSingleFactor(long N) {
71-
// N==9 would require to check if the gcd is 1 < gcd < N before returning it as a factor
72-
if (N==9) return 3;
74+
public long findSingleFactor(long nOriginal) {
75+
this.n = nOriginal<0 ? -nOriginal : nOriginal; // RNG.nextLong(n) below would crash for negative arguments
76+
77+
// n==9 would require to check if the gcd is 1 < gcd < n before returning it as a factor
78+
if (n==9) return 3;
7379

74-
this.N = N;
7580
long G, x, ys;
7681

7782
setUpMontgomeryMult();
7883

7984
// number of iterations before gcd tests.
8085
// Brent: "The probability of the algorithm failing because q_i=0 increases, so it is best not to choose m too large"
81-
final int Nbits = 64 - Long.numberOfLeadingZeros(N);
86+
final int Nbits = 64 - Long.numberOfLeadingZeros(n);
8287
final int m = 2*Nbits;
8388

8489
do {
85-
// start with random y from [0, N)
86-
long y = RNG.nextLong(N);
90+
// start with random y from [0, n)
91+
long y = RNG.nextLong(n);
8792
if (DEBUG) Ensure.ensureGreaterEquals(y, 0);
8893
int r = 1;
8994
long q = 1;
9095
do {
9196
x = y;
9297
for (int i=r; i>0; i--) {
93-
y = montMul64(y, y+1, N, minusNInvModR);
98+
y = montMul64(y, y+1, n, minusNInvModR);
9499
}
95100
int k = 0;
96101
do {
97102
ys = y;
98103
final int iMax = Math.min(m, r-k);
99104
for (int i=iMax; i>0; i--) {
100-
y = montMul64(y, y+1, N, minusNInvModR);
105+
y = montMul64(y, y+1, n, minusNInvModR);
101106
final long diff = x<y ? y-x : x-y;
102-
q = montMul64(diff, q, N, minusNInvModR);
107+
q = montMul64(diff, q, n, minusNInvModR);
103108
}
104-
G = gcd.gcd(q, N);
105-
// if q==0 then G==N -> the loop will be left and restarted with new y
109+
G = gcd.gcd(q, n);
110+
// if q==0 then G==n -> the loop will be left and restarted with new y
106111
k += m;
107112
if (DEBUG) LOG.debug("r = " + r + ", k = " + k);
108113
} while (k<r && G==1);
109114
r <<= 1;
110115
if (DEBUG) LOG.debug("r = " + r + ", G = " + G);
111116
} while (G==1);
112-
if (G==N) {
117+
if (G==n) {
113118
do {
114-
ys = montMul64(ys, ys+1, N, minusNInvModR);
119+
ys = montMul64(ys, ys+1, n, minusNInvModR);
115120
final long diff = x<ys ? ys-x : x-ys;
116-
G = gcd.gcd(diff, N);
121+
G = gcd.gcd(diff, n);
117122
} while (G==1);
118123
if (DEBUG) LOG.debug("G = " + G);
119124
}
120-
} while (G==N);
121-
if (DEBUG) LOG.debug("Found factor " + G + " of N=" + N);
125+
} while (G==n);
126+
if (DEBUG) LOG.debug("Found factor " + G + " of N=" + nOriginal);
122127
return G;
123128
}
124129

@@ -141,7 +146,7 @@ private void setUpMontgomeryMult() {
141146
u >>>= 1;
142147
v >>>= 1;
143148
} else {
144-
u = ((u ^ N) >>> 1) + (u & N);
149+
u = ((u ^ n) >>> 1) + (u & n);
145150
v = (v >>> 1) + R_HALF;
146151
}
147152
}

‎src/main/java/de/tilman_neumann/jml/factor/pollardRho/PollardRhoBrentMontgomery64MH.java

+25-20
Original file line numberDiff line numberDiff line change
@@ -55,7 +55,7 @@ public class PollardRhoBrentMontgomery64MH extends FactorAlgorithm {
5555
// The reducer R is 2^64, but the only constant still required is the half of it.
5656
private static final long R_HALF = 1L << 63;
5757

58-
private long N;
58+
private long n;
5959

6060
private long minusNInvModR; // (-1/N) mod R, required for Montgomery multiplication
6161

@@ -68,61 +68,66 @@ public String getName() {
6868

6969
@Override
7070
public BigInteger findSingleFactor(BigInteger N) {
71-
return BigInteger.valueOf(findSingleFactor(N.longValue()));
71+
if (N.bitLength() > 63) { // this check should be negligible in terms of performance
72+
throw new IllegalArgumentException("N = " + N + " has " + N.bitLength() + " bit, but " + getName() + " only supports arguments <= 63 bit");
73+
}
74+
long factorLong = findSingleFactor(N.longValue());
75+
return BigInteger.valueOf(factorLong);
7276
}
7377

74-
public long findSingleFactor(long N) {
75-
// N==9 would require to check if the gcd is 1 < gcd < N before returning it as a factor
76-
if (N==9) return 3;
78+
public long findSingleFactor(long nOriginal) {
79+
this.n = nOriginal<0 ? -nOriginal : nOriginal; // RNG.nextLong(n) below would crash for negative arguments
80+
81+
// n==9 would require to check if the gcd is 1 < gcd < n before returning it as a factor
82+
if (n==9) return 3;
7783

78-
this.N = N;
7984
long G, x, ys;
8085

8186
setUpMontgomeryMult();
8287

8388
// number of iterations before gcd tests.
8489
// Brent: "The probability of the algorithm failing because q_i=0 increases, so it is best not to choose m too large"
85-
final int Nbits = 64 - Long.numberOfLeadingZeros(N);
90+
final int Nbits = 64 - Long.numberOfLeadingZeros(n);
8691
final int m = 2*Nbits;
8792

8893
do {
89-
// start with random y from [0, N)
90-
long y = RNG.nextLong(N);
94+
// start with random y from [0, n)
95+
long y = RNG.nextLong(n);
9196
if (DEBUG) Ensure.ensureGreaterEquals(y, 0);
9297
int r = 1;
9398
long q = 1;
9499
do {
95100
x = y;
96101
for (int i=r; i>0; i--) {
97-
y = montMul64(y, y+1, N, minusNInvModR);
102+
y = montMul64(y, y+1, n, minusNInvModR);
98103
}
99104
int k = 0;
100105
do {
101106
ys = y;
102107
final int iMax = Math.min(m, r-k);
103108
for (int i=iMax; i>0; i--) {
104-
y = montMul64(y, y+1, N, minusNInvModR);
109+
y = montMul64(y, y+1, n, minusNInvModR);
105110
final long diff = x<y ? y-x : x-y;
106-
q = montMul64(diff, q, N, minusNInvModR);
111+
q = montMul64(diff, q, n, minusNInvModR);
107112
}
108-
G = gcd.gcd(q, N);
109-
// if q==0 then G==N -> the loop will be left and restarted with new y
113+
G = gcd.gcd(q, n);
114+
// if q==0 then G==n -> the loop will be left and restarted with new y
110115
k += m;
111116
if (DEBUG) LOG.debug("r = " + r + ", k = " + k);
112117
} while (k<r && G==1);
113118
r <<= 1;
114119
if (DEBUG) LOG.debug("r = " + r + ", G = " + G);
115120
} while (G==1);
116-
if (G==N) {
121+
if (G==n) {
117122
do {
118-
ys = montMul64(ys, ys+1, N, minusNInvModR);
123+
ys = montMul64(ys, ys+1, n, minusNInvModR);
119124
final long diff = x<ys ? ys-x : x-ys;
120-
G = gcd.gcd(diff, N);
125+
G = gcd.gcd(diff, n);
121126
} while (G==1);
122127
if (DEBUG) LOG.debug("G = " + G);
123128
}
124-
} while (G==N);
125-
if (DEBUG) LOG.debug("Found factor " + G + " of N=" + N);
129+
} while (G==n);
130+
if (DEBUG) LOG.debug("Found factor " + G + " of N=" + nOriginal);
126131
return G;
127132
}
128133

@@ -145,7 +150,7 @@ private void setUpMontgomeryMult() {
145150
u >>>= 1;
146151
v >>>= 1;
147152
} else {
148-
u = ((u ^ N) >>> 1) + (u & N);
153+
u = ((u ^ n) >>> 1) + (u & n);
149154
v = (v >>> 1) + R_HALF;
150155
}
151156
}

‎src/main/java/de/tilman_neumann/jml/factor/pollardRho/PollardRhoBrentMontgomery64MHInlined.java

+25-20
Original file line numberDiff line numberDiff line change
@@ -55,7 +55,7 @@ public class PollardRhoBrentMontgomery64MHInlined extends FactorAlgorithm {
5555
// The reducer R is 2^64, but the only constant still required is the half of it.
5656
private static final long R_HALF = 1L << 63;
5757

58-
private long N;
58+
private long n;
5959

6060
private long minusNInvModR; // (-1/N) mod R, required for Montgomery multiplication
6161

@@ -68,61 +68,66 @@ public String getName() {
6868

6969
@Override
7070
public BigInteger findSingleFactor(BigInteger N) {
71-
return BigInteger.valueOf(findSingleFactor(N.longValue()));
71+
if (N.bitLength() > 63) { // this check should be negligible in terms of performance
72+
throw new IllegalArgumentException("N = " + N + " has " + N.bitLength() + " bit, but " + getName() + " only supports arguments <= 63 bit");
73+
}
74+
long factorLong = findSingleFactor(N.longValue());
75+
return BigInteger.valueOf(factorLong);
7276
}
7377

74-
public long findSingleFactor(long N) {
75-
// N==9 would require to check if the gcd is 1 < gcd < N before returning it as a factor
76-
if (N==9) return 3;
78+
public long findSingleFactor(long nOriginal) {
79+
this.n = nOriginal<0 ? -nOriginal : nOriginal; // RNG.nextLong(n) below would crash for negative arguments
80+
81+
// n==9 would require to check if the gcd is 1 < gcd < n before returning it as a factor
82+
if (n==9) return 3;
7783

78-
this.N = N;
7984
long G, x, ys;
8085

8186
setUpMontgomeryMult();
8287

8388
// number of iterations before gcd tests.
8489
// Brent: "The probability of the algorithm failing because q_i=0 increases, so it is best not to choose m too large"
85-
final int Nbits = 64 - Long.numberOfLeadingZeros(N);
90+
final int Nbits = 64 - Long.numberOfLeadingZeros(n);
8691
final int m = 2*Nbits;
8792

8893
do {
89-
// start with random y from [0, N)
90-
long y = RNG.nextLong(N);
94+
// start with random y from [0, n)
95+
long y = RNG.nextLong(n);
9196
if (DEBUG) Ensure.ensureGreaterEquals(y, 0);
9297
int r = 1;
9398
long q = 1;
9499
do {
95100
x = y;
96101
for (int i=r; i>0; i--) {
97-
y = montMul64(y, y+1, N, minusNInvModR);
102+
y = montMul64(y, y+1, n, minusNInvModR);
98103
}
99104
int k = 0;
100105
do {
101106
ys = y;
102107
final int iMax = Math.min(m, r-k);
103108
for (int i=iMax; i>0; i--) {
104-
y = montMul64(y, y+1, N, minusNInvModR);
109+
y = montMul64(y, y+1, n, minusNInvModR);
105110
final long diff = x<y ? y-x : x-y;
106-
q = montMul64(diff, q, N, minusNInvModR);
111+
q = montMul64(diff, q, n, minusNInvModR);
107112
}
108-
G = gcd.gcd(q, N);
109-
// if q==0 then G==N -> the loop will be left and restarted with new y
113+
G = gcd.gcd(q, n);
114+
// if q==0 then G==n -> the loop will be left and restarted with new y
110115
k += m;
111116
if (DEBUG) LOG.debug("r = " + r + ", k = " + k);
112117
} while (k<r && G==1);
113118
r <<= 1;
114119
if (DEBUG) LOG.debug("r = " + r + ", G = " + G);
115120
} while (G==1);
116-
if (G==N) {
121+
if (G==n) {
117122
do {
118-
ys = montMul64(ys, ys+1, N, minusNInvModR);
123+
ys = montMul64(ys, ys+1, n, minusNInvModR);
119124
final long diff = x<ys ? ys-x : x-ys;
120-
G = gcd.gcd(diff, N);
125+
G = gcd.gcd(diff, n);
121126
} while (G==1);
122127
if (DEBUG) LOG.debug("G = " + G);
123128
}
124-
} while (G==N);
125-
if (DEBUG) LOG.debug("Found factor " + G + " of N=" + N);
129+
} while (G==n);
130+
if (DEBUG) LOG.debug("Found factor " + G + " of N=" + nOriginal);
126131
return G;
127132
}
128133

@@ -145,7 +150,7 @@ private void setUpMontgomeryMult() {
145150
u >>>= 1;
146151
v >>>= 1;
147152
} else {
148-
u = ((u ^ N) >>> 1) + (u & N);
153+
u = ((u ^ n) >>> 1) + (u & n);
149154
v = (v >>> 1) + R_HALF;
150155
}
151156
}

0 commit comments

Comments
 (0)