a geicko-2 based round robin ranking system designed to test c++ battleship submissions
battleship.dunkirk.sh
dunkirk.sh
1// Copyright 2019 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5// Package curve25519 provides an implementation of the X25519 function, which
6// performs scalar multiplication on the elliptic curve known as Curve25519.
7// See RFC 7748.
8//
9// This package is a wrapper for the X25519 implementation
10// in the crypto/ecdh package.
11package curve25519
12
13import "crypto/ecdh"
14
15// ScalarMult sets dst to the product scalar * point.
16//
17// Deprecated: when provided a low-order point, ScalarMult will set dst to all
18// zeroes, irrespective of the scalar. Instead, use the X25519 function, which
19// will return an error.
20func ScalarMult(dst, scalar, point *[32]byte) {
21 if _, err := x25519(dst, scalar[:], point[:]); err != nil {
22 // The only error condition for x25519 when the inputs are 32 bytes long
23 // is if the output would have been the all-zero value.
24 for i := range dst {
25 dst[i] = 0
26 }
27 }
28}
29
30// ScalarBaseMult sets dst to the product scalar * base where base is the
31// standard generator.
32//
33// It is recommended to use the X25519 function with Basepoint instead, as
34// copying into fixed size arrays can lead to unexpected bugs.
35func ScalarBaseMult(dst, scalar *[32]byte) {
36 curve := ecdh.X25519()
37 priv, err := curve.NewPrivateKey(scalar[:])
38 if err != nil {
39 panic("curve25519: internal error: scalarBaseMult was not 32 bytes")
40 }
41 copy(dst[:], priv.PublicKey().Bytes())
42}
43
44const (
45 // ScalarSize is the size of the scalar input to X25519.
46 ScalarSize = 32
47 // PointSize is the size of the point input to X25519.
48 PointSize = 32
49)
50
51// Basepoint is the canonical Curve25519 generator.
52var Basepoint []byte
53
54var basePoint = [32]byte{9}
55
56func init() { Basepoint = basePoint[:] }
57
58// X25519 returns the result of the scalar multiplication (scalar * point),
59// according to RFC 7748, Section 5. scalar, point and the return value are
60// slices of 32 bytes.
61//
62// scalar can be generated at random, for example with crypto/rand. point should
63// be either Basepoint or the output of another X25519 call.
64//
65// If point is Basepoint (but not if it's a different slice with the same
66// contents) a precomputed implementation might be used for performance.
67func X25519(scalar, point []byte) ([]byte, error) {
68 // Outline the body of function, to let the allocation be inlined in the
69 // caller, and possibly avoid escaping to the heap.
70 var dst [32]byte
71 return x25519(&dst, scalar, point)
72}
73
74func x25519(dst *[32]byte, scalar, point []byte) ([]byte, error) {
75 curve := ecdh.X25519()
76 pub, err := curve.NewPublicKey(point)
77 if err != nil {
78 return nil, err
79 }
80 priv, err := curve.NewPrivateKey(scalar)
81 if err != nil {
82 return nil, err
83 }
84 out, err := priv.ECDH(pub)
85 if err != nil {
86 return nil, err
87 }
88 copy(dst[:], out)
89 return dst[:], nil
90}