Skip to content

elliptic-curve: NonZeroScalar + Generator (replaces MulBase) - #241

Merged
tarcieri merged 1 commit into
masterfrom
elliptic-curve/non-zero-scalar
Aug 2, 2020
Merged

elliptic-curve: NonZeroScalar + Generator (replaces MulBase)#241
tarcieri merged 1 commit into
masterfrom
elliptic-curve/non-zero-scalar

Conversation

@tarcieri

@tarcieritarcieri commented Jul 31, 2020•
edited
Loading

Copy link
Copy Markdown
Member

Adds a NonZeroScalar type generic over curves along with a Generator trait which together with the Mul trait from core can replace the MulBase trait.

NonZeroScalar is able to use the bounds on Arithmetic::Scalar and therefore usable anywhere a Scalar otherwise would, but with the guarantee that multiplication by an AffinePoint will not result in the point at infinity, for which no AffinePoint representation is possible given current trait bounds/implementations.

cc @fjarri

@tarcieri
tarcieri requested a review from str4dJuly 31, 2020 18:49
fjarri
fjarri reviewed Jul 31, 2020
View reviewed changes
Comment threadelliptic-curve/src/scalar.rs Outdated
/// Create a [`NonZeroScalar`] from a scalar, performing a constant-time
/// check that it's non-zero.
pub fn new(scalar: S) -> CtOption<Self> {
let is_some = scalar.ct_eq(&S::default());

@fjarrifjarriJul 31, 2020

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It's a bit weird using default() and not zero()/is_zero(), but I guess it's the best that can be done at the moment. Should probably be refactored when there's a fully-functional Scalar trait (or a collection of traits) is available.

@tarcieritarcieriJul 31, 2020•
edited
Loading

Copy link
Copy Markdown
MemberAuthor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yeah, it's the only extant trait to define this in terms of right now.

However, I wouldn't say it's "weird" per se, at least for usage of Default in Rust: zero is the Default value for all numerical types in the standard library.

@fjarrifjarriJul 31, 2020

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I suppose it's ok for simple types, but this approach may fail if Scalar ever implements lazy reduction arithmetic similar to that in FieldElement (and it will fail for the current AffinePoint/ProjectivePoint), because in that case you could have something that is zero/identity and yet isn't default().

@tarcieri
tarcieriforce-pushed the elliptic-curve/non-zero-scalar branch 2 times, most recently from fabba1e to f420e79CompareAugust 2, 2020 17:50
@tarcieritarcieri changed the title elliptic-curve: NonZeroScalar typeelliptic-curve: NonZeroScalar + Generator (replaces MulBase)Aug 2, 2020
@tarcieri

tarcieri commented Aug 2, 2020

Copy link
Copy Markdown
MemberAuthor

Pushed up a slightly modified version of this PR, and also added Generator to it and removed MulBase. I have k256 wired up with all of this locally.

I changed NonZeroScalar to be generic over Curve + Arithmetic, which allows it to reuse the trait bounds for Arithmetic::Scalar. Perhaps a better solution here would be a Scalar trait, but I think that's something to explore in a separate PR.

I think I'm going to move forward with this for now as it also solves the problem of generic variable-base scalar mult in addition to fixed-base, which is useful for a high-level generic ECDHE API. That's not to say I consider this to be the final say here, just incremental progress in exposing more functionality.

@tarcieri
elliptic-curve: NonZeroScalar + Generator (replaces MulBase)
c1bcc90
Adds a `NonZeroScalar` type generic over curves along with a `Generator`
trait which together with the `Mul` trait from `core` can replace the
`MulBase` trait.
`NonZeroScalar` is able to use the bounds on `Arithmetic::Scalar` and
therefore usable anywhere a `Scalar` otherwise would, but with the
guarantee that multiplication by an `AffinePoint` will not result in the
point at infinity, for which no `AffinePoint` representation is possible
given current trait bounds/implementations.
@tarcieri
tarcieriforce-pushed the elliptic-curve/non-zero-scalar branch from f420e79 to c1bcc90CompareAugust 2, 2020 17:57
@tarcieri
tarcieri merged commit efefde4 into masterAug 2, 2020
@tarcieri
tarcieri deleted the elliptic-curve/non-zero-scalar branch August 2, 2020 18:03
tarcieri added a commit to RustCrypto/elliptic-curves that referenced this pull request Aug 2, 2020
@tarcieri
k256/p256: replace MulBase with Mul+NonZeroScalar+Generator
ec43210
Impls the changes from RustCrypto/traits#241, replacing the `MulBase`
trait with a `Mul` impl on `AffinePoint`, which is now one of the
required bounds for `Arithmetic`.
@tarcieritarcieri mentioned this pull request Aug 2, 2020
Merged
tarcieri added a commit to RustCrypto/elliptic-curves that referenced this pull request Aug 2, 2020
@tarcieri
k256/p256: replace MulBase with Mul+NonZeroScalar+Generator (#106)
006c224
Impls the changes from RustCrypto/traits#241, replacing the `MulBase`
trait with a `Mul` impl on `AffinePoint`, which is now one of the
required bounds for `Arithmetic`.
@tarcieritarcieri mentioned this pull request Aug 10, 2020
Merged
@tarcieritarcieri mentioned this pull request Sep 5, 2020
Merged
dns2utf8 pushed a commit to dns2utf8/traits that referenced this pull request Jan 24, 2023
@tarcieri
sha-crypt: test cleanup (RustCrypto#241)
db88376
Simplify test vectors
Sign up for freeto join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

@str4dstr4dAwaiting requested review from str4d
1 more reviewer
@fjarrifjarrifjarri left review comments
Reviewers whose approvals may not affect merge requirements

Assignees

No one assigned

Labels

None yet

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

2 participants

@tarcieri@fjarri
, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
elliptic-curve: NonZeroScalar + Generator (replaces MulBase) by tarcieri · Pull Request #241 · RustCrypto/traits · GitHub
Skip to content
elliptic-curve: NonZeroScalar + Generator (replaces MulBase) - #241
Merged
tarcieri merged 1 commit into
masterfrom 
elliptic-curve/non-zero-scalar
Aug 2, 2020
Merged
elliptic-curve: NonZeroScalar + Generator (replaces MulBase)#241
tarcieri merged 1 commit into
masterfrom 
elliptic-curve/non-zero-scalar
Conversation
@tarcieri
@tarcieritarcieri
commented
Jul 31, 2020•

edited

Loading

Copy link


Copy Markdown

Member
Adds a NonZeroScalar type generic over curves along with a Generator trait which together with the Mul trait from core can replace the MulBase trait.
NonZeroScalar is able to use the bounds on Arithmetic::Scalar and therefore usable anywhere a Scalar otherwise would, but with the guarantee that multiplication by an AffinePoint will not result in the point at infinity, for which no AffinePoint representation is possible given current trait bounds/implementations.
cc @fjarri
@tarcieri
tarcieri
requested a review
from str4dJuly 31, 2020 18:49
fjarri
fjarri
reviewed
Jul 31, 2020
View reviewed changes
Comment threadelliptic-curve/src/scalar.rs
Outdated

 /// Create a [`NonZeroScalar`] from a scalar, performing a constant-time
 /// check that it's non-zero.
 pub fn new(scalar: S) -> CtOption<Self> {
 let is_some = scalar.ct_eq(&S::default());
@fjarrifjarriJul 31, 2020

Copy link


Copy Markdown

Contributor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It's a bit weird using default() and not zero()/is_zero(), but I guess it's the best that can be done at the moment. Should probably be refactored when there's a fully-functional Scalar trait (or a collection of traits) is available.
@tarcieritarcieriJul 31, 2020•

edited

Loading

Copy link


Copy Markdown

MemberAuthor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yeah, it's the only extant trait to define this in terms of right now.
However, I wouldn't say it's "weird" per se, at least for usage of Default in Rust: zero is the Default value for all numerical types in the standard library.
@fjarrifjarriJul 31, 2020

Copy link


Copy Markdown

Contributor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I suppose it's ok for simple types, but this approach may fail if Scalar ever implements lazy reduction arithmetic similar to that in FieldElement (and it will fail for the current AffinePoint/ProjectivePoint), because in that case you could have something that is zero/identity and yet isn't default().
@tarcieri
tarcieriforce-pushed
the
elliptic-curve/non-zero-scalar
branch
2 times, most recently
from
fabba1e to
f420e79CompareAugust 2, 2020 17:50
@tarcieritarcieri
changed the title
elliptic-curve: NonZeroScalar typeelliptic-curve: NonZeroScalar + Generator (replaces MulBase)Aug 2, 2020
@tarcieri
tarcieri
commented
Aug 2, 2020

Copy link


Copy Markdown

MemberAuthor
Pushed up a slightly modified version of this PR, and also added Generator to it and removed MulBase. I have k256 wired up with all of this locally.
I changed NonZeroScalar to be generic over Curve + Arithmetic, which allows it to reuse the trait bounds for Arithmetic::Scalar. Perhaps a better solution here would be a Scalar trait, but I think that's something to explore in a separate PR.
I think I'm going to move forward with this for now as it also solves the problem of generic variable-base scalar mult in addition to fixed-base, which is useful for a high-level generic ECDHE API. That's not to say I consider this to be the final say here, just incremental progress in exposing more functionality.
@tarcieri
elliptic-curve: NonZeroScalar + Generator (replaces MulBase)
c1bcc90
Adds a `NonZeroScalar` type generic over curves along with a `Generator`
trait which together with the `Mul` trait from `core` can replace the
`MulBase` trait.
`NonZeroScalar` is able to use the bounds on `Arithmetic::Scalar` and
therefore usable anywhere a `Scalar` otherwise would, but with the
guarantee that multiplication by an `AffinePoint` will not result in the
point at infinity, for which no `AffinePoint` representation is possible
given current trait bounds/implementations.
@tarcieri
tarcieriforce-pushed
the
elliptic-curve/non-zero-scalar
branch
from
f420e79 to
c1bcc90CompareAugust 2, 2020 17:57
@tarcieri
tarcieri
merged commit efefde4
into
masterAug 2, 2020
@tarcieri
tarcieri
deleted the

elliptic-curve/non-zero-scalar

branch
August 2, 2020 18:03
tarcieri added a commit
to RustCrypto/elliptic-curves
that referenced
this pull request
Aug 2, 2020
@tarcieri
k256/p256: replace MulBase with Mul+NonZeroScalar+Generator
ec43210
Impls the changes from RustCrypto/traits#241, replacing the `MulBase`
trait with a `Mul` impl on `AffinePoint`, which is now one of the
required bounds for `Arithmetic`.
@tarcieritarcieri
mentioned this pull request
Aug 2, 2020
 Merged

tarcieri added a commit
to RustCrypto/elliptic-curves
that referenced
this pull request
Aug 2, 2020
@tarcieri
k256/p256: replace MulBase with Mul+NonZeroScalar+Generator (#106)
006c224
Impls the changes from RustCrypto/traits#241, replacing the `MulBase`
trait with a `Mul` impl on `AffinePoint`, which is now one of the
required bounds for `Arithmetic`.
@tarcieritarcieri
mentioned this pull request
Aug 10, 2020
 Merged

@tarcieritarcieri
mentioned this pull request
Sep 5, 2020
 Merged

dns2utf8 pushed a commit
to dns2utf8/traits
that referenced
this pull request
Jan 24, 2023
@tarcieri
sha-crypt: test cleanup (RustCrypto#241)
db88376
Simplify test vectors
Sign up for freeto join this conversation on GitHub.
Already have an account?
Sign in to comment

Reviewers

@str4dstr4dAwaiting requested review from str4d

1 more reviewer

@fjarrifjarrifjarri left review comments
Reviewers whose approvals may not affect merge requirements

Assignees


No one assigned


Labels


None yet


Projects


None yet


Milestone


No milestone


Development

Successfully merging this pull request may close these issues.

2 participants

@tarcieri@fjarri

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
elliptic-curve: NonZeroScalar + Generator (replaces MulBase) by tarcieri · Pull Request #241 · RustCrypto/traits · GitHub
Skip to content
elliptic-curve: NonZeroScalar + Generator (replaces MulBase) - #241
Merged
tarcieri merged 1 commit into
masterfrom 
elliptic-curve/non-zero-scalar
Aug 2, 2020
Merged
elliptic-curve: NonZeroScalar + Generator (replaces MulBase)#241
tarcieri merged 1 commit into
masterfrom 
elliptic-curve/non-zero-scalar
Conversation
@tarcieri
@tarcieritarcieri
commented
Jul 31, 2020•

edited

Loading

Copy link


Copy Markdown

Member
Adds a NonZeroScalar type generic over curves along with a Generator trait which together with the Mul trait from core can replace the MulBase trait.
NonZeroScalar is able to use the bounds on Arithmetic::Scalar and therefore usable anywhere a Scalar otherwise would, but with the guarantee that multiplication by an AffinePoint will not result in the point at infinity, for which no AffinePoint representation is possible given current trait bounds/implementations.
cc @fjarri
@tarcieri
tarcieri
requested a review
from str4dJuly 31, 2020 18:49
fjarri
fjarri
reviewed
Jul 31, 2020
View reviewed changes
Comment threadelliptic-curve/src/scalar.rs
Outdated

 /// Create a [`NonZeroScalar`] from a scalar, performing a constant-time
 /// check that it's non-zero.
 pub fn new(scalar: S) -> CtOption<Self> {
 let is_some = scalar.ct_eq(&S::default());
@fjarrifjarriJul 31, 2020

Copy link


Copy Markdown

Contributor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It's a bit weird using default() and not zero()/is_zero(), but I guess it's the best that can be done at the moment. Should probably be refactored when there's a fully-functional Scalar trait (or a collection of traits) is available.
@tarcieritarcieriJul 31, 2020•

edited

Loading

Copy link


Copy Markdown

MemberAuthor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yeah, it's the only extant trait to define this in terms of right now.
However, I wouldn't say it's "weird" per se, at least for usage of Default in Rust: zero is the Default value for all numerical types in the standard library.
@fjarrifjarriJul 31, 2020

Copy link


Copy Markdown

Contributor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I suppose it's ok for simple types, but this approach may fail if Scalar ever implements lazy reduction arithmetic similar to that in FieldElement (and it will fail for the current AffinePoint/ProjectivePoint), because in that case you could have something that is zero/identity and yet isn't default().
@tarcieri
tarcieriforce-pushed
the
elliptic-curve/non-zero-scalar
branch
2 times, most recently
from
fabba1e to
f420e79CompareAugust 2, 2020 17:50
@tarcieritarcieri
changed the title
elliptic-curve: NonZeroScalar typeelliptic-curve: NonZeroScalar + Generator (replaces MulBase)Aug 2, 2020
@tarcieri
tarcieri
commented
Aug 2, 2020

Copy link


Copy Markdown

MemberAuthor
Pushed up a slightly modified version of this PR, and also added Generator to it and removed MulBase. I have k256 wired up with all of this locally.
I changed NonZeroScalar to be generic over Curve + Arithmetic, which allows it to reuse the trait bounds for Arithmetic::Scalar. Perhaps a better solution here would be a Scalar trait, but I think that's something to explore in a separate PR.
I think I'm going to move forward with this for now as it also solves the problem of generic variable-base scalar mult in addition to fixed-base, which is useful for a high-level generic ECDHE API. That's not to say I consider this to be the final say here, just incremental progress in exposing more functionality.
@tarcieri
elliptic-curve: NonZeroScalar + Generator (replaces MulBase)
c1bcc90
Adds a `NonZeroScalar` type generic over curves along with a `Generator`
trait which together with the `Mul` trait from `core` can replace the
`MulBase` trait.
`NonZeroScalar` is able to use the bounds on `Arithmetic::Scalar` and
therefore usable anywhere a `Scalar` otherwise would, but with the
guarantee that multiplication by an `AffinePoint` will not result in the
point at infinity, for which no `AffinePoint` representation is possible
given current trait bounds/implementations.
@tarcieri
tarcieriforce-pushed
the
elliptic-curve/non-zero-scalar
branch
from
f420e79 to
c1bcc90CompareAugust 2, 2020 17:57
@tarcieri
tarcieri
merged commit efefde4
into
masterAug 2, 2020
@tarcieri
tarcieri
deleted the

elliptic-curve/non-zero-scalar

branch
August 2, 2020 18:03
tarcieri added a commit
to RustCrypto/elliptic-curves
that referenced
this pull request
Aug 2, 2020
@tarcieri
k256/p256: replace MulBase with Mul+NonZeroScalar+Generator
ec43210
Impls the changes from RustCrypto/traits#241, replacing the `MulBase`
trait with a `Mul` impl on `AffinePoint`, which is now one of the
required bounds for `Arithmetic`.
@tarcieritarcieri
mentioned this pull request
Aug 2, 2020
 Merged

tarcieri added a commit
to RustCrypto/elliptic-curves
that referenced
this pull request
Aug 2, 2020
@tarcieri
k256/p256: replace MulBase with Mul+NonZeroScalar+Generator (#106)
006c224
Impls the changes from RustCrypto/traits#241, replacing the `MulBase`
trait with a `Mul` impl on `AffinePoint`, which is now one of the
required bounds for `Arithmetic`.
@tarcieritarcieri
mentioned this pull request
Aug 10, 2020
 Merged

@tarcieritarcieri
mentioned this pull request
Sep 5, 2020
 Merged

dns2utf8 pushed a commit
to dns2utf8/traits
that referenced
this pull request
Jan 24, 2023
@tarcieri
sha-crypt: test cleanup (RustCrypto#241)
db88376
Simplify test vectors
Sign up for freeto join this conversation on GitHub.
Already have an account?
Sign in to comment

Reviewers

@str4dstr4dAwaiting requested review from str4d

1 more reviewer

@fjarrifjarrifjarri left review comments
Reviewers whose approvals may not affect merge requirements

Assignees


No one assigned


Labels


None yet


Projects


None yet


Milestone


No milestone


Development

Successfully merging this pull request may close these issues.

2 participants

@tarcieri@fjarri

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
elliptic-curve: NonZeroScalar + Generator (replaces MulBase) by tarcieri · Pull Request #241 · RustCrypto/traits · GitHub
Skip to content
elliptic-curve: NonZeroScalar + Generator (replaces MulBase) - #241
Merged
tarcieri merged 1 commit into
masterfrom 
elliptic-curve/non-zero-scalar
Aug 2, 2020
Merged
elliptic-curve: NonZeroScalar + Generator (replaces MulBase)#241
tarcieri merged 1 commit into
masterfrom 
elliptic-curve/non-zero-scalar
Conversation
@tarcieri
@tarcieritarcieri
commented
Jul 31, 2020•

edited

Loading

Copy link


Copy Markdown

Member
Adds a NonZeroScalar type generic over curves along with a Generator trait which together with the Mul trait from core can replace the MulBase trait.
NonZeroScalar is able to use the bounds on Arithmetic::Scalar and therefore usable anywhere a Scalar otherwise would, but with the guarantee that multiplication by an AffinePoint will not result in the point at infinity, for which no AffinePoint representation is possible given current trait bounds/implementations.
cc @fjarri
@tarcieri
tarcieri
requested a review
from str4dJuly 31, 2020 18:49
fjarri
fjarri
reviewed
Jul 31, 2020
View reviewed changes
Comment threadelliptic-curve/src/scalar.rs
Outdated

 /// Create a [`NonZeroScalar`] from a scalar, performing a constant-time
 /// check that it's non-zero.
 pub fn new(scalar: S) -> CtOption<Self> {
 let is_some = scalar.ct_eq(&S::default());
@fjarrifjarriJul 31, 2020

Copy link


Copy Markdown

Contributor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It's a bit weird using default() and not zero()/is_zero(), but I guess it's the best that can be done at the moment. Should probably be refactored when there's a fully-functional Scalar trait (or a collection of traits) is available.
@tarcieritarcieriJul 31, 2020•

edited

Loading

Copy link


Copy Markdown

MemberAuthor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yeah, it's the only extant trait to define this in terms of right now.
However, I wouldn't say it's "weird" per se, at least for usage of Default in Rust: zero is the Default value for all numerical types in the standard library.
@fjarrifjarriJul 31, 2020

Copy link


Copy Markdown

Contributor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I suppose it's ok for simple types, but this approach may fail if Scalar ever implements lazy reduction arithmetic similar to that in FieldElement (and it will fail for the current AffinePoint/ProjectivePoint), because in that case you could have something that is zero/identity and yet isn't default().
@tarcieri
tarcieriforce-pushed
the
elliptic-curve/non-zero-scalar
branch
2 times, most recently
from
fabba1e to
f420e79CompareAugust 2, 2020 17:50
@tarcieritarcieri
changed the title
elliptic-curve: NonZeroScalar typeelliptic-curve: NonZeroScalar + Generator (replaces MulBase)Aug 2, 2020
@tarcieri
tarcieri
commented
Aug 2, 2020

Copy link


Copy Markdown

MemberAuthor
Pushed up a slightly modified version of this PR, and also added Generator to it and removed MulBase. I have k256 wired up with all of this locally.
I changed NonZeroScalar to be generic over Curve + Arithmetic, which allows it to reuse the trait bounds for Arithmetic::Scalar. Perhaps a better solution here would be a Scalar trait, but I think that's something to explore in a separate PR.
I think I'm going to move forward with this for now as it also solves the problem of generic variable-base scalar mult in addition to fixed-base, which is useful for a high-level generic ECDHE API. That's not to say I consider this to be the final say here, just incremental progress in exposing more functionality.
@tarcieri
elliptic-curve: NonZeroScalar + Generator (replaces MulBase)
c1bcc90
Adds a `NonZeroScalar` type generic over curves along with a `Generator`
trait which together with the `Mul` trait from `core` can replace the
`MulBase` trait.
`NonZeroScalar` is able to use the bounds on `Arithmetic::Scalar` and
therefore usable anywhere a `Scalar` otherwise would, but with the
guarantee that multiplication by an `AffinePoint` will not result in the
point at infinity, for which no `AffinePoint` representation is possible
given current trait bounds/implementations.
@tarcieri
tarcieriforce-pushed
the
elliptic-curve/non-zero-scalar
branch
from
f420e79 to
c1bcc90CompareAugust 2, 2020 17:57
@tarcieri
tarcieri
merged commit efefde4
into
masterAug 2, 2020
@tarcieri
tarcieri
deleted the

elliptic-curve/non-zero-scalar

branch
August 2, 2020 18:03
tarcieri added a commit
to RustCrypto/elliptic-curves
that referenced
this pull request
Aug 2, 2020
@tarcieri
k256/p256: replace MulBase with Mul+NonZeroScalar+Generator
ec43210
Impls the changes from RustCrypto/traits#241, replacing the `MulBase`
trait with a `Mul` impl on `AffinePoint`, which is now one of the
required bounds for `Arithmetic`.
@tarcieritarcieri
mentioned this pull request
Aug 2, 2020
 Merged

tarcieri added a commit
to RustCrypto/elliptic-curves
that referenced
this pull request
Aug 2, 2020
@tarcieri
k256/p256: replace MulBase with Mul+NonZeroScalar+Generator (#106)
006c224
Impls the changes from RustCrypto/traits#241, replacing the `MulBase`
trait with a `Mul` impl on `AffinePoint`, which is now one of the
required bounds for `Arithmetic`.
@tarcieritarcieri
mentioned this pull request
Aug 10, 2020
 Merged

@tarcieritarcieri
mentioned this pull request
Sep 5, 2020
 Merged

dns2utf8 pushed a commit
to dns2utf8/traits
that referenced
this pull request
Jan 24, 2023
@tarcieri
sha-crypt: test cleanup (RustCrypto#241)
db88376
Simplify test vectors
Sign up for freeto join this conversation on GitHub.
Already have an account?
Sign in to comment

Reviewers

@str4dstr4dAwaiting requested review from str4d

1 more reviewer

@fjarrifjarrifjarri left review comments
Reviewers whose approvals may not affect merge requirements

Assignees


No one assigned


Labels


None yet


Projects


None yet


Milestone


No milestone


Development

Successfully merging this pull request may close these issues.

2 participants

@tarcieri@fjarri

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
elliptic-curve: NonZeroScalar + Generator (replaces MulBase) by tarcieri · Pull Request #241 · RustCrypto/traits · GitHub
Skip to content
elliptic-curve: NonZeroScalar + Generator (replaces MulBase) - #241
Merged
tarcieri merged 1 commit into
masterfrom 
elliptic-curve/non-zero-scalar
Aug 2, 2020
Merged
elliptic-curve: NonZeroScalar + Generator (replaces MulBase)#241
tarcieri merged 1 commit into
masterfrom 
elliptic-curve/non-zero-scalar
Conversation
@tarcieri
@tarcieritarcieri
commented
Jul 31, 2020•

edited

Loading

Copy link


Copy Markdown

Member
Adds a NonZeroScalar type generic over curves along with a Generator trait which together with the Mul trait from core can replace the MulBase trait.
NonZeroScalar is able to use the bounds on Arithmetic::Scalar and therefore usable anywhere a Scalar otherwise would, but with the guarantee that multiplication by an AffinePoint will not result in the point at infinity, for which no AffinePoint representation is possible given current trait bounds/implementations.
cc @fjarri
@tarcieri
tarcieri
requested a review
from str4dJuly 31, 2020 18:49
fjarri
fjarri
reviewed
Jul 31, 2020
View reviewed changes
Comment threadelliptic-curve/src/scalar.rs
Outdated

 /// Create a [`NonZeroScalar`] from a scalar, performing a constant-time
 /// check that it's non-zero.
 pub fn new(scalar: S) -> CtOption<Self> {
 let is_some = scalar.ct_eq(&S::default());
@fjarrifjarriJul 31, 2020

Copy link


Copy Markdown

Contributor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It's a bit weird using default() and not zero()/is_zero(), but I guess it's the best that can be done at the moment. Should probably be refactored when there's a fully-functional Scalar trait (or a collection of traits) is available.
@tarcieritarcieriJul 31, 2020•

edited

Loading

Copy link


Copy Markdown

MemberAuthor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yeah, it's the only extant trait to define this in terms of right now.
However, I wouldn't say it's "weird" per se, at least for usage of Default in Rust: zero is the Default value for all numerical types in the standard library.
@fjarrifjarriJul 31, 2020

Copy link


Copy Markdown

Contributor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I suppose it's ok for simple types, but this approach may fail if Scalar ever implements lazy reduction arithmetic similar to that in FieldElement (and it will fail for the current AffinePoint/ProjectivePoint), because in that case you could have something that is zero/identity and yet isn't default().
@tarcieri
tarcieriforce-pushed
the
elliptic-curve/non-zero-scalar
branch
2 times, most recently
from
fabba1e to
f420e79CompareAugust 2, 2020 17:50
@tarcieritarcieri
changed the title
elliptic-curve: NonZeroScalar typeelliptic-curve: NonZeroScalar + Generator (replaces MulBase)Aug 2, 2020
@tarcieri
tarcieri
commented
Aug 2, 2020

Copy link


Copy Markdown

MemberAuthor
Pushed up a slightly modified version of this PR, and also added Generator to it and removed MulBase. I have k256 wired up with all of this locally.
I changed NonZeroScalar to be generic over Curve + Arithmetic, which allows it to reuse the trait bounds for Arithmetic::Scalar. Perhaps a better solution here would be a Scalar trait, but I think that's something to explore in a separate PR.
I think I'm going to move forward with this for now as it also solves the problem of generic variable-base scalar mult in addition to fixed-base, which is useful for a high-level generic ECDHE API. That's not to say I consider this to be the final say here, just incremental progress in exposing more functionality.
@tarcieri
elliptic-curve: NonZeroScalar + Generator (replaces MulBase)
c1bcc90
Adds a `NonZeroScalar` type generic over curves along with a `Generator`
trait which together with the `Mul` trait from `core` can replace the
`MulBase` trait.
`NonZeroScalar` is able to use the bounds on `Arithmetic::Scalar` and
therefore usable anywhere a `Scalar` otherwise would, but with the
guarantee that multiplication by an `AffinePoint` will not result in the
point at infinity, for which no `AffinePoint` representation is possible
given current trait bounds/implementations.
@tarcieri
tarcieriforce-pushed
the
elliptic-curve/non-zero-scalar
branch
from
f420e79 to
c1bcc90CompareAugust 2, 2020 17:57
@tarcieri
tarcieri
merged commit efefde4
into
masterAug 2, 2020
@tarcieri
tarcieri
deleted the

elliptic-curve/non-zero-scalar

branch
August 2, 2020 18:03
tarcieri added a commit
to RustCrypto/elliptic-curves
that referenced
this pull request
Aug 2, 2020
@tarcieri
k256/p256: replace MulBase with Mul+NonZeroScalar+Generator
ec43210
Impls the changes from RustCrypto/traits#241, replacing the `MulBase`
trait with a `Mul` impl on `AffinePoint`, which is now one of the
required bounds for `Arithmetic`.
@tarcieritarcieri
mentioned this pull request
Aug 2, 2020
 Merged

tarcieri added a commit
to RustCrypto/elliptic-curves
that referenced
this pull request
Aug 2, 2020
@tarcieri
k256/p256: replace MulBase with Mul+NonZeroScalar+Generator (#106)
006c224
Impls the changes from RustCrypto/traits#241, replacing the `MulBase`
trait with a `Mul` impl on `AffinePoint`, which is now one of the
required bounds for `Arithmetic`.
@tarcieritarcieri
mentioned this pull request
Aug 10, 2020
 Merged

@tarcieritarcieri
mentioned this pull request
Sep 5, 2020
 Merged

dns2utf8 pushed a commit
to dns2utf8/traits
that referenced
this pull request
Jan 24, 2023
@tarcieri
sha-crypt: test cleanup (RustCrypto#241)
db88376
Simplify test vectors
Sign up for freeto join this conversation on GitHub.
Already have an account?
Sign in to comment

Reviewers

@str4dstr4dAwaiting requested review from str4d

1 more reviewer

@fjarrifjarrifjarri left review comments
Reviewers whose approvals may not affect merge requirements

Assignees


No one assigned


Labels


None yet


Projects


None yet


Milestone


No milestone


Development

Successfully merging this pull request may close these issues.

2 participants

@tarcieri@fjarri

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
elliptic-curve: NonZeroScalar + Generator (replaces MulBase) by tarcieri · Pull Request #241 · RustCrypto/traits · GitHub
Skip to content
elliptic-curve: NonZeroScalar + Generator (replaces MulBase) - #241
Merged
tarcieri merged 1 commit into
masterfrom 
elliptic-curve/non-zero-scalar
Aug 2, 2020
Merged
elliptic-curve: NonZeroScalar + Generator (replaces MulBase)#241
tarcieri merged 1 commit into
masterfrom 
elliptic-curve/non-zero-scalar
Conversation
@tarcieri
@tarcieritarcieri
commented
Jul 31, 2020•

edited

Loading

Copy link


Copy Markdown

Member
Adds a NonZeroScalar type generic over curves along with a Generator trait which together with the Mul trait from core can replace the MulBase trait.
NonZeroScalar is able to use the bounds on Arithmetic::Scalar and therefore usable anywhere a Scalar otherwise would, but with the guarantee that multiplication by an AffinePoint will not result in the point at infinity, for which no AffinePoint representation is possible given current trait bounds/implementations.
cc @fjarri
@tarcieri
tarcieri
requested a review
from str4dJuly 31, 2020 18:49
fjarri
fjarri
reviewed
Jul 31, 2020
View reviewed changes
Comment threadelliptic-curve/src/scalar.rs
Outdated

 /// Create a [`NonZeroScalar`] from a scalar, performing a constant-time
 /// check that it's non-zero.
 pub fn new(scalar: S) -> CtOption<Self> {
 let is_some = scalar.ct_eq(&S::default());
@fjarrifjarriJul 31, 2020

Copy link


Copy Markdown

Contributor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It's a bit weird using default() and not zero()/is_zero(), but I guess it's the best that can be done at the moment. Should probably be refactored when there's a fully-functional Scalar trait (or a collection of traits) is available.
@tarcieritarcieriJul 31, 2020•

edited

Loading

Copy link


Copy Markdown

MemberAuthor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yeah, it's the only extant trait to define this in terms of right now.
However, I wouldn't say it's "weird" per se, at least for usage of Default in Rust: zero is the Default value for all numerical types in the standard library.
@fjarrifjarriJul 31, 2020

Copy link


Copy Markdown

Contributor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I suppose it's ok for simple types, but this approach may fail if Scalar ever implements lazy reduction arithmetic similar to that in FieldElement (and it will fail for the current AffinePoint/ProjectivePoint), because in that case you could have something that is zero/identity and yet isn't default().
@tarcieri
tarcieriforce-pushed
the
elliptic-curve/non-zero-scalar
branch
2 times, most recently
from
fabba1e to
f420e79CompareAugust 2, 2020 17:50
@tarcieritarcieri
changed the title
elliptic-curve: NonZeroScalar typeelliptic-curve: NonZeroScalar + Generator (replaces MulBase)Aug 2, 2020
@tarcieri
tarcieri
commented
Aug 2, 2020

Copy link


Copy Markdown

MemberAuthor
Pushed up a slightly modified version of this PR, and also added Generator to it and removed MulBase. I have k256 wired up with all of this locally.
I changed NonZeroScalar to be generic over Curve + Arithmetic, which allows it to reuse the trait bounds for Arithmetic::Scalar. Perhaps a better solution here would be a Scalar trait, but I think that's something to explore in a separate PR.
I think I'm going to move forward with this for now as it also solves the problem of generic variable-base scalar mult in addition to fixed-base, which is useful for a high-level generic ECDHE API. That's not to say I consider this to be the final say here, just incremental progress in exposing more functionality.
@tarcieri
elliptic-curve: NonZeroScalar + Generator (replaces MulBase)
c1bcc90
Adds a `NonZeroScalar` type generic over curves along with a `Generator`
trait which together with the `Mul` trait from `core` can replace the
`MulBase` trait.
`NonZeroScalar` is able to use the bounds on `Arithmetic::Scalar` and
therefore usable anywhere a `Scalar` otherwise would, but with the
guarantee that multiplication by an `AffinePoint` will not result in the
point at infinity, for which no `AffinePoint` representation is possible
given current trait bounds/implementations.
@tarcieri
tarcieriforce-pushed
the
elliptic-curve/non-zero-scalar
branch
from
f420e79 to
c1bcc90CompareAugust 2, 2020 17:57
@tarcieri
tarcieri
merged commit efefde4
into
masterAug 2, 2020
@tarcieri
tarcieri
deleted the

elliptic-curve/non-zero-scalar

branch
August 2, 2020 18:03
tarcieri added a commit
to RustCrypto/elliptic-curves
that referenced
this pull request
Aug 2, 2020
@tarcieri
k256/p256: replace MulBase with Mul+NonZeroScalar+Generator
ec43210
Impls the changes from RustCrypto/traits#241, replacing the `MulBase`
trait with a `Mul` impl on `AffinePoint`, which is now one of the
required bounds for `Arithmetic`.
@tarcieritarcieri
mentioned this pull request
Aug 2, 2020
 Merged

tarcieri added a commit
to RustCrypto/elliptic-curves
that referenced
this pull request
Aug 2, 2020
@tarcieri
k256/p256: replace MulBase with Mul+NonZeroScalar+Generator (#106)
006c224
Impls the changes from RustCrypto/traits#241, replacing the `MulBase`
trait with a `Mul` impl on `AffinePoint`, which is now one of the
required bounds for `Arithmetic`.
@tarcieritarcieri
mentioned this pull request
Aug 10, 2020
 Merged

@tarcieritarcieri
mentioned this pull request
Sep 5, 2020
 Merged

dns2utf8 pushed a commit
to dns2utf8/traits
that referenced
this pull request
Jan 24, 2023
@tarcieri
sha-crypt: test cleanup (RustCrypto#241)
db88376
Simplify test vectors
Sign up for freeto join this conversation on GitHub.
Already have an account?
Sign in to comment

Reviewers

@str4dstr4dAwaiting requested review from str4d

1 more reviewer

@fjarrifjarrifjarri left review comments
Reviewers whose approvals may not affect merge requirements

Assignees


No one assigned


Labels


None yet


Projects


None yet


Milestone


No milestone


Development

Successfully merging this pull request may close these issues.

2 participants

@tarcieri@fjarri

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
elliptic-curve: NonZeroScalar + Generator (replaces MulBase) by tarcieri · Pull Request #241 · RustCrypto/traits · GitHub
Skip to content
elliptic-curve: NonZeroScalar + Generator (replaces MulBase) - #241
Merged
tarcieri merged 1 commit into
masterfrom 
elliptic-curve/non-zero-scalar
Aug 2, 2020
Merged
elliptic-curve: NonZeroScalar + Generator (replaces MulBase)#241
tarcieri merged 1 commit into
masterfrom 
elliptic-curve/non-zero-scalar
Conversation
@tarcieri
@tarcieritarcieri
commented
Jul 31, 2020•

edited

Loading

Copy link


Copy Markdown

Member
Adds a NonZeroScalar type generic over curves along with a Generator trait which together with the Mul trait from core can replace the MulBase trait.
NonZeroScalar is able to use the bounds on Arithmetic::Scalar and therefore usable anywhere a Scalar otherwise would, but with the guarantee that multiplication by an AffinePoint will not result in the point at infinity, for which no AffinePoint representation is possible given current trait bounds/implementations.
cc @fjarri
@tarcieri
tarcieri
requested a review
from str4dJuly 31, 2020 18:49
fjarri
fjarri
reviewed
Jul 31, 2020
View reviewed changes
Comment threadelliptic-curve/src/scalar.rs
Outdated

 /// Create a [`NonZeroScalar`] from a scalar, performing a constant-time
 /// check that it's non-zero.
 pub fn new(scalar: S) -> CtOption<Self> {
 let is_some = scalar.ct_eq(&S::default());
@fjarrifjarriJul 31, 2020

Copy link


Copy Markdown

Contributor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It's a bit weird using default() and not zero()/is_zero(), but I guess it's the best that can be done at the moment. Should probably be refactored when there's a fully-functional Scalar trait (or a collection of traits) is available.
@tarcieritarcieriJul 31, 2020•

edited

Loading

Copy link


Copy Markdown

MemberAuthor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yeah, it's the only extant trait to define this in terms of right now.
However, I wouldn't say it's "weird" per se, at least for usage of Default in Rust: zero is the Default value for all numerical types in the standard library.
@fjarrifjarriJul 31, 2020

Copy link


Copy Markdown

Contributor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I suppose it's ok for simple types, but this approach may fail if Scalar ever implements lazy reduction arithmetic similar to that in FieldElement (and it will fail for the current AffinePoint/ProjectivePoint), because in that case you could have something that is zero/identity and yet isn't default().
@tarcieri
tarcieriforce-pushed
the
elliptic-curve/non-zero-scalar
branch
2 times, most recently
from
fabba1e to
f420e79CompareAugust 2, 2020 17:50
@tarcieritarcieri
changed the title
elliptic-curve: NonZeroScalar typeelliptic-curve: NonZeroScalar + Generator (replaces MulBase)Aug 2, 2020
@tarcieri
tarcieri
commented
Aug 2, 2020

Copy link


Copy Markdown

MemberAuthor
Pushed up a slightly modified version of this PR, and also added Generator to it and removed MulBase. I have k256 wired up with all of this locally.
I changed NonZeroScalar to be generic over Curve + Arithmetic, which allows it to reuse the trait bounds for Arithmetic::Scalar. Perhaps a better solution here would be a Scalar trait, but I think that's something to explore in a separate PR.
I think I'm going to move forward with this for now as it also solves the problem of generic variable-base scalar mult in addition to fixed-base, which is useful for a high-level generic ECDHE API. That's not to say I consider this to be the final say here, just incremental progress in exposing more functionality.
@tarcieri
elliptic-curve: NonZeroScalar + Generator (replaces MulBase)
c1bcc90
Adds a `NonZeroScalar` type generic over curves along with a `Generator`
trait which together with the `Mul` trait from `core` can replace the
`MulBase` trait.
`NonZeroScalar` is able to use the bounds on `Arithmetic::Scalar` and
therefore usable anywhere a `Scalar` otherwise would, but with the
guarantee that multiplication by an `AffinePoint` will not result in the
point at infinity, for which no `AffinePoint` representation is possible
given current trait bounds/implementations.
@tarcieri
tarcieriforce-pushed
the
elliptic-curve/non-zero-scalar
branch
from
f420e79 to
c1bcc90CompareAugust 2, 2020 17:57
@tarcieri
tarcieri
merged commit efefde4
into
masterAug 2, 2020
@tarcieri
tarcieri
deleted the

elliptic-curve/non-zero-scalar

branch
August 2, 2020 18:03
tarcieri added a commit
to RustCrypto/elliptic-curves
that referenced
this pull request
Aug 2, 2020
@tarcieri
k256/p256: replace MulBase with Mul+NonZeroScalar+Generator
ec43210
Impls the changes from RustCrypto/traits#241, replacing the `MulBase`
trait with a `Mul` impl on `AffinePoint`, which is now one of the
required bounds for `Arithmetic`.
@tarcieritarcieri
mentioned this pull request
Aug 2, 2020
 Merged

tarcieri added a commit
to RustCrypto/elliptic-curves
that referenced
this pull request
Aug 2, 2020
@tarcieri
k256/p256: replace MulBase with Mul+NonZeroScalar+Generator (#106)
006c224
Impls the changes from RustCrypto/traits#241, replacing the `MulBase`
trait with a `Mul` impl on `AffinePoint`, which is now one of the
required bounds for `Arithmetic`.
@tarcieritarcieri
mentioned this pull request
Aug 10, 2020
 Merged

@tarcieritarcieri
mentioned this pull request
Sep 5, 2020
 Merged

dns2utf8 pushed a commit
to dns2utf8/traits
that referenced
this pull request
Jan 24, 2023
@tarcieri
sha-crypt: test cleanup (RustCrypto#241)
db88376
Simplify test vectors
Sign up for freeto join this conversation on GitHub.
Already have an account?
Sign in to comment

Reviewers

@str4dstr4dAwaiting requested review from str4d

1 more reviewer

@fjarrifjarrifjarri left review comments
Reviewers whose approvals may not affect merge requirements

Assignees


No one assigned


Labels


None yet


Projects


None yet


Milestone


No milestone


Development

Successfully merging this pull request may close these issues.

2 participants

@tarcieri@fjarri

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
elliptic-curve: NonZeroScalar + Generator (replaces MulBase) by tarcieri · Pull Request #241 · RustCrypto/traits · GitHub
Skip to content
elliptic-curve: NonZeroScalar + Generator (replaces MulBase) - #241
Merged
tarcieri merged 1 commit into
masterfrom 
elliptic-curve/non-zero-scalar
Aug 2, 2020
Merged
elliptic-curve: NonZeroScalar + Generator (replaces MulBase)#241
tarcieri merged 1 commit into
masterfrom 
elliptic-curve/non-zero-scalar
Conversation
@tarcieri
@tarcieritarcieri
commented
Jul 31, 2020•

edited

Loading

Copy link


Copy Markdown

Member
Adds a NonZeroScalar type generic over curves along with a Generator trait which together with the Mul trait from core can replace the MulBase trait.
NonZeroScalar is able to use the bounds on Arithmetic::Scalar and therefore usable anywhere a Scalar otherwise would, but with the guarantee that multiplication by an AffinePoint will not result in the point at infinity, for which no AffinePoint representation is possible given current trait bounds/implementations.
cc @fjarri
@tarcieri
tarcieri
requested a review
from str4dJuly 31, 2020 18:49
fjarri
fjarri
reviewed
Jul 31, 2020
View reviewed changes
Comment threadelliptic-curve/src/scalar.rs
Outdated

 /// Create a [`NonZeroScalar`] from a scalar, performing a constant-time
 /// check that it's non-zero.
 pub fn new(scalar: S) -> CtOption<Self> {
 let is_some = scalar.ct_eq(&S::default());
@fjarrifjarriJul 31, 2020

Copy link


Copy Markdown

Contributor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It's a bit weird using default() and not zero()/is_zero(), but I guess it's the best that can be done at the moment. Should probably be refactored when there's a fully-functional Scalar trait (or a collection of traits) is available.
@tarcieritarcieriJul 31, 2020•

edited

Loading

Copy link


Copy Markdown

MemberAuthor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yeah, it's the only extant trait to define this in terms of right now.
However, I wouldn't say it's "weird" per se, at least for usage of Default in Rust: zero is the Default value for all numerical types in the standard library.
@fjarrifjarriJul 31, 2020

Copy link


Copy Markdown

Contributor
Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I suppose it's ok for simple types, but this approach may fail if Scalar ever implements lazy reduction arithmetic similar to that in FieldElement (and it will fail for the current AffinePoint/ProjectivePoint), because in that case you could have something that is zero/identity and yet isn't default().
@tarcieri
tarcieriforce-pushed
the
elliptic-curve/non-zero-scalar
branch
2 times, most recently
from
fabba1e to
f420e79CompareAugust 2, 2020 17:50
@tarcieritarcieri
changed the title
elliptic-curve: NonZeroScalar typeelliptic-curve: NonZeroScalar + Generator (replaces MulBase)Aug 2, 2020
@tarcieri
tarcieri
commented
Aug 2, 2020

Copy link


Copy Markdown

MemberAuthor
Pushed up a slightly modified version of this PR, and also added Generator to it and removed MulBase. I have k256 wired up with all of this locally.
I changed NonZeroScalar to be generic over Curve + Arithmetic, which allows it to reuse the trait bounds for Arithmetic::Scalar. Perhaps a better solution here would be a Scalar trait, but I think that's something to explore in a separate PR.
I think I'm going to move forward with this for now as it also solves the problem of generic variable-base scalar mult in addition to fixed-base, which is useful for a high-level generic ECDHE API. That's not to say I consider this to be the final say here, just incremental progress in exposing more functionality.
@tarcieri
elliptic-curve: NonZeroScalar + Generator (replaces MulBase)
c1bcc90
Adds a `NonZeroScalar` type generic over curves along with a `Generator`
trait which together with the `Mul` trait from `core` can replace the
`MulBase` trait.
`NonZeroScalar` is able to use the bounds on `Arithmetic::Scalar` and
therefore usable anywhere a `Scalar` otherwise would, but with the
guarantee that multiplication by an `AffinePoint` will not result in the
point at infinity, for which no `AffinePoint` representation is possible
given current trait bounds/implementations.
@tarcieri
tarcieriforce-pushed
the
elliptic-curve/non-zero-scalar
branch
from
f420e79 to
c1bcc90CompareAugust 2, 2020 17:57
@tarcieri
tarcieri
merged commit efefde4
into
masterAug 2, 2020
@tarcieri
tarcieri
deleted the

elliptic-curve/non-zero-scalar

branch
August 2, 2020 18:03
tarcieri added a commit
to RustCrypto/elliptic-curves
that referenced
this pull request
Aug 2, 2020
@tarcieri
k256/p256: replace MulBase with Mul+NonZeroScalar+Generator
ec43210
Impls the changes from RustCrypto/traits#241, replacing the `MulBase`
trait with a `Mul` impl on `AffinePoint`, which is now one of the
required bounds for `Arithmetic`.
@tarcieritarcieri
mentioned this pull request
Aug 2, 2020
 Merged

tarcieri added a commit
to RustCrypto/elliptic-curves
that referenced
this pull request
Aug 2, 2020
@tarcieri
k256/p256: replace MulBase with Mul+NonZeroScalar+Generator (#106)
006c224
Impls the changes from RustCrypto/traits#241, replacing the `MulBase`
trait with a `Mul` impl on `AffinePoint`, which is now one of the
required bounds for `Arithmetic`.
@tarcieritarcieri
mentioned this pull request
Aug 10, 2020
 Merged

@tarcieritarcieri
mentioned this pull request
Sep 5, 2020
 Merged

dns2utf8 pushed a commit
to dns2utf8/traits
that referenced
this pull request
Jan 24, 2023
@tarcieri
sha-crypt: test cleanup (RustCrypto#241)
db88376
Simplify test vectors
Sign up for freeto join this conversation on GitHub.
Already have an account?
Sign in to comment

Reviewers

@str4dstr4dAwaiting requested review from str4d

1 more reviewer

@fjarrifjarrifjarri left review comments
Reviewers whose approvals may not affect merge requirements

Assignees


No one assigned


Labels


None yet


Projects


None yet


Milestone


No milestone


Development

Successfully merging this pull request may close these issues.

2 participants

@tarcieri@fjarri