From 9ae4b930830813fed6004414cb07bdce38b73e33 Mon Sep 17 00:00:00 2001 From: tsingbx Date: Tue, 30 Jul 2024 18:32:27 +0800 Subject: [PATCH 1/4] add openssl sha1,sha256,sha512 --- _demo/cshademo/sha.go | 29 ++++++++++++ c/openssl/sha.go | 31 +++++++++++++ c/openssl/sha1.go | 63 ++++++++++++++++++++++++++ c/openssl/sha256.go | 103 ++++++++++++++++++++++++++++++++++++++++++ c/openssl/sha512.go | 101 +++++++++++++++++++++++++++++++++++++++++ ssa/expr.go | 10 ++++ 6 files changed, 337 insertions(+) create mode 100644 _demo/cshademo/sha.go create mode 100644 c/openssl/sha.go create mode 100644 c/openssl/sha1.go create mode 100644 c/openssl/sha256.go create mode 100644 c/openssl/sha512.go diff --git a/_demo/cshademo/sha.go b/_demo/cshademo/sha.go new file mode 100644 index 00000000..ad58d8f8 --- /dev/null +++ b/_demo/cshademo/sha.go @@ -0,0 +1,29 @@ +package main + +import ( + "fmt" + "unsafe" + + "github.com/goplus/llgo/c/openssl" +) + +func main() { + + var sha1 openssl.SHA_CTX + sha1.Init() + sha1.UpdateString("His money is twice tainted:") + sha1.UpdateString(" 'taint yours and 'taint mine.") + + h := make([]byte, openssl.SHA_DIGEST_LENGTH) + sha1.Final(unsafe.SliceData(h)) + fmt.Printf("%x\n", h) + + var sha256 openssl.SHA256_CTX + sha256.Init() + sha256.UpdateString("His money is twice tainted:") + sha256.UpdateString(" 'taint yours and 'taint mine.") + + hh := make([]byte, openssl.SHA256_DIGEST_LENGTH) + sha256.Final(unsafe.SliceData(hh)) + fmt.Printf("%x\n", hh) +} diff --git a/c/openssl/sha.go b/c/openssl/sha.go new file mode 100644 index 00000000..3cf7d891 --- /dev/null +++ b/c/openssl/sha.go @@ -0,0 +1,31 @@ +package openssl + +import "github.com/goplus/llgo/c" + +const ( + SHA_DIGEST_LENGTH = 20 + SHA_LBLOCK = 16 + SHA_CBLOCK = (SHA_LBLOCK * 4) + SHA_LAST_BLOCK = (SHA_CBLOCK - 8) + + SHA256_CBLOCK = (SHA_LBLOCK * 4) + SHA256_192_DIGEST_LENGTH = 24 + SHA224_DIGEST_LENGTH = 28 + SHA256_DIGEST_LENGTH = 32 + SHA384_DIGEST_LENGTH = 48 + SHA512_DIGEST_LENGTH = 64 + SHA512_CBLOCK = (SHA_LBLOCK * 8) +) + +/* +# if (defined(_WIN32) || defined(_WIN64)) && !defined(__MINGW32__) +# define SHA_LONG64 unsigned __int64 +# elif defined(__arch64__) +# define SHA_LONG64 unsigned long +# else +# define SHA_LONG64 unsigned long long +# endif +*/ +type SHA_LONG64 = c.UlongLong + +type SHA_LONG = c.Uint diff --git a/c/openssl/sha1.go b/c/openssl/sha1.go new file mode 100644 index 00000000..6ca7f6b2 --- /dev/null +++ b/c/openssl/sha1.go @@ -0,0 +1,63 @@ +package openssl + +import ( + "unsafe" + + "github.com/goplus/llgo/c" +) + +type SHA_CTX struct { + H0, H1, H2, H3, H4 SHA_LONG + Nl, Nh SHA_LONG + Data [SHA_LBLOCK]SHA_LONG + Num c.Uint +} + +// OSSL_DEPRECATEDIN_3_0 int SHA1_Init(SHA_CTX *c); +// +// llgo:link (*SHA_CTX).Init C.SHA1_Init +func (c *SHA_CTX) Init() c.Int { return 0 } + +// OSSL_DEPRECATEDIN_3_0 int SHA1_Update(SHA_CTX *c, const void *data, size_t len); +// +// llgo:link (*SHA_CTX).Update C.SHA1_Update +func (c *SHA_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 } + +func (c *SHA_CTX) UpdateBytes(data []byte) c.Int { + return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data))) +} + +func (c *SHA_CTX) UpdateString(data string) c.Int { + return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data))) +} + +// OSSL_DEPRECATEDIN_3_0 int SHA1_Final(unsigned char *md, SHA_CTX *c); +// +//go:linkname sha1Final C.SHA1_Final +func sha1Final(md *byte, c *SHA_CTX) c.Int + +func (c *SHA_CTX) Final(md *byte) c.Int { + return sha1Final(md, c) +} + +// OSSL_DEPRECATEDIN_3_0 void SHA1_Transform(SHA_CTX *c, const unsigned char *data); +// +//go:linkname sha1Transform C.SHA1_Transform +func sha1Transform(c *SHA_CTX, data *byte) + +func (c *SHA_CTX) Transform(data *byte) { + sha1Transform(c, data) +} + +// unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md); +// +//go:linkname SHA1 C.SHA1 +func SHA1(data unsafe.Pointer, n uintptr, md *byte) *byte + +func SHA1Bytes(data []byte, md *byte) *byte { + return SHA1(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md) +} + +func SHA1String(data string, md *byte) *byte { + return SHA1(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md) +} diff --git a/c/openssl/sha256.go b/c/openssl/sha256.go new file mode 100644 index 00000000..d18e3a2d --- /dev/null +++ b/c/openssl/sha256.go @@ -0,0 +1,103 @@ +package openssl + +import ( + "unsafe" + + "github.com/goplus/llgo/c" +) + +type SHA256_CTX struct { + H [8]SHA_LONG + Nl, Nh SHA_LONG + Data [SHA_LBLOCK]SHA_LONG + Num, MdLen c.Uint +} + +// OSSL_DEPRECATEDIN_3_0 int SHA224_Init(SHA256_CTX *c); +// +// llgo:link (*SHA256_CTX).Init224 C.SHA224_Init +func (c *SHA256_CTX) Init224() c.Int { return 0 } + +// OSSL_DEPRECATEDIN_3_0 int SHA224_Update(SHA256_CTX *c, const void *data, size_t len); +// +// llgo:link (*SHA256_CTX).Update224 C.SHA224_Update +func (c *SHA256_CTX) Update224(data unsafe.Pointer, n uintptr) c.Int { return 0 } + +func (c *SHA256_CTX) Update224Bytes(data []byte) c.Int { + return c.Update224(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data))) +} + +func (c *SHA256_CTX) Update224String(data string) c.Int { + return c.Update224(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data))) +} + +// OSSL_DEPRECATEDIN_3_0 int SHA224_Final(unsigned char *md, SHA256_CTX *c); +// +//go:linkname sha224Final C.SHA224_Final +func sha224Final(md *byte, c *SHA256_CTX) c.Int + +func (c *SHA256_CTX) Final224(md *byte) c.Int { + return sha224Final(md, c) +} + +// OSSL_DEPRECATEDIN_3_0 int SHA256_Init(SHA256_CTX *c); +// +// llgo:link (*SHA256_CTX).Init C.SHA256_Init +func (c *SHA256_CTX) Init() c.Int { return 0 } + +// OSSL_DEPRECATEDIN_3_0 int SHA256_Update(SHA256_CTX *c, const void *data, size_t len); +// +// llgo:link (*SHA256_CTX).Update C.SHA256_Update +func (c *SHA256_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 } + +func (c *SHA256_CTX) UpdateBytes(data []byte) c.Int { + return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data))) +} + +func (c *SHA256_CTX) UpdateString(data string) c.Int { + return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data))) +} + +// OSSL_DEPRECATEDIN_3_0 int SHA256_Final(unsigned char *md, SHA256_CTX *c); +// +//go:linkname sha256Final C.SHA256_Final +func sha256Final(md *byte, c *SHA256_CTX) c.Int + +func (c *SHA256_CTX) Final(md *byte) c.Int { + return sha256Final(md, c) +} + +// OSSL_DEPRECATEDIN_3_0 void SHA256_Transform(SHA256_CTX *c, const unsigned char *data); +// +//go:linkname sha256Transform C.SHA256_Transform +func sha256Transform(c *SHA256_CTX, data *byte) + +func (c *SHA256_CTX) Transform(data *byte) { + sha256Transform(c, data) +} + +// unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md); +// +//go:linkname SHA224 C.SHA224 +func SHA224(data unsafe.Pointer, n uintptr, md *byte) *byte + +func SHA224Bytes(data []byte, md *byte) *byte { + return SHA224(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md) +} + +func SHA224String(data string, md *byte) *byte { + return SHA224(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md) +} + +// unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md); +// +//go:linkname SHA256 C.SHA256 +func SHA256(data unsafe.Pointer, n uintptr, md *byte) *byte + +func SHA256Bytes(data []byte, md *byte) *byte { + return SHA256(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md) +} + +func SHA256String(data string, md *byte) *byte { + return SHA256(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md) +} diff --git a/c/openssl/sha512.go b/c/openssl/sha512.go new file mode 100644 index 00000000..6add73b7 --- /dev/null +++ b/c/openssl/sha512.go @@ -0,0 +1,101 @@ +package openssl + +import ( + "unsafe" + + "github.com/goplus/llgo/c" +) + +type SHA512_CTX struct { + H [8]SHA_LONG64 + N1, Nh SHA_LONG64 + D [SHA_LBLOCK]SHA_LONG64 + Num, MdLen c.Uint +} + +// OSSL_DEPRECATEDIN_3_0 int SHA384_Init(SHA512_CTX *c); +// +// llgo:link (*SHA512_CTX).Init384 C.SHA384_Init +func (c *SHA512_CTX) Init384() c.Int { return 0 } + +// OSSL_DEPRECATEDIN_3_0 int SHA384_Update(SHA512_CTX *c, const void *data, size_t len); +// +// llgo:link (*SHA512_CTX).Update384 C.SHA384_Update +func (c *SHA512_CTX) Update384(data unsafe.Pointer, n uintptr) c.Int { return 0 } + +func (c *SHA512_CTX) Update384Bytes(data []byte) c.Int { + return c.Update384(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data))) +} + +func (c *SHA512_CTX) Update384String(data string) c.Int { + return c.Update384(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data))) +} + +// OSSL_DEPRECATEDIN_3_0 int SHA384_Final(unsigned char *md, SHA512_CTX *c); +// +//go:linkname sha384Final C.SHA384_Final +func sha384Final(md *byte, c *SHA512_CTX) c.Int + +func (c *SHA512_CTX) Final384(md *byte) c.Int { + return sha384Final(md, c) +} + +// OSSL_DEPRECATEDIN_3_0 int SHA512_Init(SHA512_CTX *c); +// +// llgo:link (*SHA512_CTX).Init C.SHA512_Init +func (c *SHA512_CTX) Init() c.Int { return 0 } + +// OSSL_DEPRECATEDIN_3_0 int SHA512_Update(SHA512_CTX *c, const void *data, size_t len); +// +// llgo:link (*SHA512_CTX).Update C.SHA512_Update +func (c *SHA512_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 } +func (c *SHA512_CTX) UpdateBytes(data []byte) c.Int { + return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data))) +} +func (c *SHA512_CTX) UpdateString(data string) c.Int { + return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data))) +} + +// OSSL_DEPRECATEDIN_3_0 int SHA512_Final(unsigned char *md, SHA512_CTX *c); +// +//go:linkname sha512Final C.SHA512_Final +func sha512Final(md *byte, c *SHA512_CTX) c.Int + +func (c *SHA512_CTX) Final(md *byte) c.Int { + return sha512Final(md, c) +} + +// OSSL_DEPRECATEDIN_3_0 void SHA512_Transform(SHA512_CTX *c, const unsigned char *data); +// +//go:linkname sha512Transform C.SHA512_Transform +func sha512Transform(c *SHA512_CTX, data *byte) + +func (c *SHA512_CTX) Transform(data *byte) { + sha512Transform(c, data) +} + +// unsigned char *SHA384(const unsigned char *d, size_t n, unsigned char *md); +// +//go:linkname SHA384 C.SHA384 +func SHA384(data unsafe.Pointer, n uintptr, md *byte) *byte + +func SHA384Bytes(data []byte, md *byte) *byte { + return SHA384(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md) +} + +func SHA384String(data string, md *byte) *byte { + return SHA384(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md) +} + +// unsigned char *SHA512(const unsigned char *d, size_t n, unsigned char *md); +// +//go:linkname SHA512 C.SHA512 +func SHA512(data unsafe.Pointer, n uintptr, md *byte) *byte + +func SHA512Bytes(data []byte, md *byte) *byte { + return SHA512(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md) +} + +func SHA512String(data string, md *byte) *byte { + return SHA512(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md) +} diff --git a/ssa/expr.go b/ssa/expr.go index 263ebb7a..f9adbd7d 100644 --- a/ssa/expr.go +++ b/ssa/expr.go @@ -1022,6 +1022,10 @@ func (b Builder) Do(da DoAction, fn Expr, args ...Expr) (ret Expr) { // Go spec (excluding "make" and "new"). func (b Builder) BuiltinCall(fn string, args ...Expr) (ret Expr) { switch fn { + case "max": + fallthrough + case "min": + return b.max(args...) case "len": if len(args) == 1 { arg := args[0] @@ -1128,6 +1132,12 @@ func (b Builder) BuiltinCall(fn string, args ...Expr) (ret Expr) { panic("todo: " + fn) } +// max return the max value for the args +func (b Builder) max(args ...Expr) (ret Expr) { + //todo + return args[len(args)-1] +} + // Println prints the arguments to stderr, followed by a newline. func (b Builder) Println(args ...Expr) (ret Expr) { return b.PrintEx(true, args...) From cd32d6debec35850bc4a18be23814461a0907515 Mon Sep 17 00:00:00 2001 From: tsingbx Date: Tue, 30 Jul 2024 18:32:27 +0800 Subject: [PATCH 2/4] add openssl sha1,sha256,sha512 --- _demo/cshademo/sha.go | 29 ++++++++++++ c/openssl/sha.go | 31 +++++++++++++ c/openssl/sha1.go | 63 ++++++++++++++++++++++++++ c/openssl/sha256.go | 103 ++++++++++++++++++++++++++++++++++++++++++ c/openssl/sha512.go | 101 +++++++++++++++++++++++++++++++++++++++++ ssa/expr.go | 10 ++++ 6 files changed, 337 insertions(+) create mode 100644 _demo/cshademo/sha.go create mode 100644 c/openssl/sha.go create mode 100644 c/openssl/sha1.go create mode 100644 c/openssl/sha256.go create mode 100644 c/openssl/sha512.go diff --git a/_demo/cshademo/sha.go b/_demo/cshademo/sha.go new file mode 100644 index 00000000..ad58d8f8 --- /dev/null +++ b/_demo/cshademo/sha.go @@ -0,0 +1,29 @@ +package main + +import ( + "fmt" + "unsafe" + + "github.com/goplus/llgo/c/openssl" +) + +func main() { + + var sha1 openssl.SHA_CTX + sha1.Init() + sha1.UpdateString("His money is twice tainted:") + sha1.UpdateString(" 'taint yours and 'taint mine.") + + h := make([]byte, openssl.SHA_DIGEST_LENGTH) + sha1.Final(unsafe.SliceData(h)) + fmt.Printf("%x\n", h) + + var sha256 openssl.SHA256_CTX + sha256.Init() + sha256.UpdateString("His money is twice tainted:") + sha256.UpdateString(" 'taint yours and 'taint mine.") + + hh := make([]byte, openssl.SHA256_DIGEST_LENGTH) + sha256.Final(unsafe.SliceData(hh)) + fmt.Printf("%x\n", hh) +} diff --git a/c/openssl/sha.go b/c/openssl/sha.go new file mode 100644 index 00000000..3cf7d891 --- /dev/null +++ b/c/openssl/sha.go @@ -0,0 +1,31 @@ +package openssl + +import "github.com/goplus/llgo/c" + +const ( + SHA_DIGEST_LENGTH = 20 + SHA_LBLOCK = 16 + SHA_CBLOCK = (SHA_LBLOCK * 4) + SHA_LAST_BLOCK = (SHA_CBLOCK - 8) + + SHA256_CBLOCK = (SHA_LBLOCK * 4) + SHA256_192_DIGEST_LENGTH = 24 + SHA224_DIGEST_LENGTH = 28 + SHA256_DIGEST_LENGTH = 32 + SHA384_DIGEST_LENGTH = 48 + SHA512_DIGEST_LENGTH = 64 + SHA512_CBLOCK = (SHA_LBLOCK * 8) +) + +/* +# if (defined(_WIN32) || defined(_WIN64)) && !defined(__MINGW32__) +# define SHA_LONG64 unsigned __int64 +# elif defined(__arch64__) +# define SHA_LONG64 unsigned long +# else +# define SHA_LONG64 unsigned long long +# endif +*/ +type SHA_LONG64 = c.UlongLong + +type SHA_LONG = c.Uint diff --git a/c/openssl/sha1.go b/c/openssl/sha1.go new file mode 100644 index 00000000..6ca7f6b2 --- /dev/null +++ b/c/openssl/sha1.go @@ -0,0 +1,63 @@ +package openssl + +import ( + "unsafe" + + "github.com/goplus/llgo/c" +) + +type SHA_CTX struct { + H0, H1, H2, H3, H4 SHA_LONG + Nl, Nh SHA_LONG + Data [SHA_LBLOCK]SHA_LONG + Num c.Uint +} + +// OSSL_DEPRECATEDIN_3_0 int SHA1_Init(SHA_CTX *c); +// +// llgo:link (*SHA_CTX).Init C.SHA1_Init +func (c *SHA_CTX) Init() c.Int { return 0 } + +// OSSL_DEPRECATEDIN_3_0 int SHA1_Update(SHA_CTX *c, const void *data, size_t len); +// +// llgo:link (*SHA_CTX).Update C.SHA1_Update +func (c *SHA_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 } + +func (c *SHA_CTX) UpdateBytes(data []byte) c.Int { + return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data))) +} + +func (c *SHA_CTX) UpdateString(data string) c.Int { + return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data))) +} + +// OSSL_DEPRECATEDIN_3_0 int SHA1_Final(unsigned char *md, SHA_CTX *c); +// +//go:linkname sha1Final C.SHA1_Final +func sha1Final(md *byte, c *SHA_CTX) c.Int + +func (c *SHA_CTX) Final(md *byte) c.Int { + return sha1Final(md, c) +} + +// OSSL_DEPRECATEDIN_3_0 void SHA1_Transform(SHA_CTX *c, const unsigned char *data); +// +//go:linkname sha1Transform C.SHA1_Transform +func sha1Transform(c *SHA_CTX, data *byte) + +func (c *SHA_CTX) Transform(data *byte) { + sha1Transform(c, data) +} + +// unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md); +// +//go:linkname SHA1 C.SHA1 +func SHA1(data unsafe.Pointer, n uintptr, md *byte) *byte + +func SHA1Bytes(data []byte, md *byte) *byte { + return SHA1(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md) +} + +func SHA1String(data string, md *byte) *byte { + return SHA1(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md) +} diff --git a/c/openssl/sha256.go b/c/openssl/sha256.go new file mode 100644 index 00000000..d18e3a2d --- /dev/null +++ b/c/openssl/sha256.go @@ -0,0 +1,103 @@ +package openssl + +import ( + "unsafe" + + "github.com/goplus/llgo/c" +) + +type SHA256_CTX struct { + H [8]SHA_LONG + Nl, Nh SHA_LONG + Data [SHA_LBLOCK]SHA_LONG + Num, MdLen c.Uint +} + +// OSSL_DEPRECATEDIN_3_0 int SHA224_Init(SHA256_CTX *c); +// +// llgo:link (*SHA256_CTX).Init224 C.SHA224_Init +func (c *SHA256_CTX) Init224() c.Int { return 0 } + +// OSSL_DEPRECATEDIN_3_0 int SHA224_Update(SHA256_CTX *c, const void *data, size_t len); +// +// llgo:link (*SHA256_CTX).Update224 C.SHA224_Update +func (c *SHA256_CTX) Update224(data unsafe.Pointer, n uintptr) c.Int { return 0 } + +func (c *SHA256_CTX) Update224Bytes(data []byte) c.Int { + return c.Update224(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data))) +} + +func (c *SHA256_CTX) Update224String(data string) c.Int { + return c.Update224(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data))) +} + +// OSSL_DEPRECATEDIN_3_0 int SHA224_Final(unsigned char *md, SHA256_CTX *c); +// +//go:linkname sha224Final C.SHA224_Final +func sha224Final(md *byte, c *SHA256_CTX) c.Int + +func (c *SHA256_CTX) Final224(md *byte) c.Int { + return sha224Final(md, c) +} + +// OSSL_DEPRECATEDIN_3_0 int SHA256_Init(SHA256_CTX *c); +// +// llgo:link (*SHA256_CTX).Init C.SHA256_Init +func (c *SHA256_CTX) Init() c.Int { return 0 } + +// OSSL_DEPRECATEDIN_3_0 int SHA256_Update(SHA256_CTX *c, const void *data, size_t len); +// +// llgo:link (*SHA256_CTX).Update C.SHA256_Update +func (c *SHA256_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 } + +func (c *SHA256_CTX) UpdateBytes(data []byte) c.Int { + return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data))) +} + +func (c *SHA256_CTX) UpdateString(data string) c.Int { + return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data))) +} + +// OSSL_DEPRECATEDIN_3_0 int SHA256_Final(unsigned char *md, SHA256_CTX *c); +// +//go:linkname sha256Final C.SHA256_Final +func sha256Final(md *byte, c *SHA256_CTX) c.Int + +func (c *SHA256_CTX) Final(md *byte) c.Int { + return sha256Final(md, c) +} + +// OSSL_DEPRECATEDIN_3_0 void SHA256_Transform(SHA256_CTX *c, const unsigned char *data); +// +//go:linkname sha256Transform C.SHA256_Transform +func sha256Transform(c *SHA256_CTX, data *byte) + +func (c *SHA256_CTX) Transform(data *byte) { + sha256Transform(c, data) +} + +// unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md); +// +//go:linkname SHA224 C.SHA224 +func SHA224(data unsafe.Pointer, n uintptr, md *byte) *byte + +func SHA224Bytes(data []byte, md *byte) *byte { + return SHA224(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md) +} + +func SHA224String(data string, md *byte) *byte { + return SHA224(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md) +} + +// unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md); +// +//go:linkname SHA256 C.SHA256 +func SHA256(data unsafe.Pointer, n uintptr, md *byte) *byte + +func SHA256Bytes(data []byte, md *byte) *byte { + return SHA256(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md) +} + +func SHA256String(data string, md *byte) *byte { + return SHA256(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md) +} diff --git a/c/openssl/sha512.go b/c/openssl/sha512.go new file mode 100644 index 00000000..6add73b7 --- /dev/null +++ b/c/openssl/sha512.go @@ -0,0 +1,101 @@ +package openssl + +import ( + "unsafe" + + "github.com/goplus/llgo/c" +) + +type SHA512_CTX struct { + H [8]SHA_LONG64 + N1, Nh SHA_LONG64 + D [SHA_LBLOCK]SHA_LONG64 + Num, MdLen c.Uint +} + +// OSSL_DEPRECATEDIN_3_0 int SHA384_Init(SHA512_CTX *c); +// +// llgo:link (*SHA512_CTX).Init384 C.SHA384_Init +func (c *SHA512_CTX) Init384() c.Int { return 0 } + +// OSSL_DEPRECATEDIN_3_0 int SHA384_Update(SHA512_CTX *c, const void *data, size_t len); +// +// llgo:link (*SHA512_CTX).Update384 C.SHA384_Update +func (c *SHA512_CTX) Update384(data unsafe.Pointer, n uintptr) c.Int { return 0 } + +func (c *SHA512_CTX) Update384Bytes(data []byte) c.Int { + return c.Update384(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data))) +} + +func (c *SHA512_CTX) Update384String(data string) c.Int { + return c.Update384(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data))) +} + +// OSSL_DEPRECATEDIN_3_0 int SHA384_Final(unsigned char *md, SHA512_CTX *c); +// +//go:linkname sha384Final C.SHA384_Final +func sha384Final(md *byte, c *SHA512_CTX) c.Int + +func (c *SHA512_CTX) Final384(md *byte) c.Int { + return sha384Final(md, c) +} + +// OSSL_DEPRECATEDIN_3_0 int SHA512_Init(SHA512_CTX *c); +// +// llgo:link (*SHA512_CTX).Init C.SHA512_Init +func (c *SHA512_CTX) Init() c.Int { return 0 } + +// OSSL_DEPRECATEDIN_3_0 int SHA512_Update(SHA512_CTX *c, const void *data, size_t len); +// +// llgo:link (*SHA512_CTX).Update C.SHA512_Update +func (c *SHA512_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 } +func (c *SHA512_CTX) UpdateBytes(data []byte) c.Int { + return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data))) +} +func (c *SHA512_CTX) UpdateString(data string) c.Int { + return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data))) +} + +// OSSL_DEPRECATEDIN_3_0 int SHA512_Final(unsigned char *md, SHA512_CTX *c); +// +//go:linkname sha512Final C.SHA512_Final +func sha512Final(md *byte, c *SHA512_CTX) c.Int + +func (c *SHA512_CTX) Final(md *byte) c.Int { + return sha512Final(md, c) +} + +// OSSL_DEPRECATEDIN_3_0 void SHA512_Transform(SHA512_CTX *c, const unsigned char *data); +// +//go:linkname sha512Transform C.SHA512_Transform +func sha512Transform(c *SHA512_CTX, data *byte) + +func (c *SHA512_CTX) Transform(data *byte) { + sha512Transform(c, data) +} + +// unsigned char *SHA384(const unsigned char *d, size_t n, unsigned char *md); +// +//go:linkname SHA384 C.SHA384 +func SHA384(data unsafe.Pointer, n uintptr, md *byte) *byte + +func SHA384Bytes(data []byte, md *byte) *byte { + return SHA384(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md) +} + +func SHA384String(data string, md *byte) *byte { + return SHA384(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md) +} + +// unsigned char *SHA512(const unsigned char *d, size_t n, unsigned char *md); +// +//go:linkname SHA512 C.SHA512 +func SHA512(data unsafe.Pointer, n uintptr, md *byte) *byte + +func SHA512Bytes(data []byte, md *byte) *byte { + return SHA512(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md) +} + +func SHA512String(data string, md *byte) *byte { + return SHA512(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md) +} diff --git a/ssa/expr.go b/ssa/expr.go index 263ebb7a..f9adbd7d 100644 --- a/ssa/expr.go +++ b/ssa/expr.go @@ -1022,6 +1022,10 @@ func (b Builder) Do(da DoAction, fn Expr, args ...Expr) (ret Expr) { // Go spec (excluding "make" and "new"). func (b Builder) BuiltinCall(fn string, args ...Expr) (ret Expr) { switch fn { + case "max": + fallthrough + case "min": + return b.max(args...) case "len": if len(args) == 1 { arg := args[0] @@ -1128,6 +1132,12 @@ func (b Builder) BuiltinCall(fn string, args ...Expr) (ret Expr) { panic("todo: " + fn) } +// max return the max value for the args +func (b Builder) max(args ...Expr) (ret Expr) { + //todo + return args[len(args)-1] +} + // Println prints the arguments to stderr, followed by a newline. func (b Builder) Println(args ...Expr) (ret Expr) { return b.PrintEx(true, args...) From 6e24792b9ba1384cb4d683bdf83df83e9a408ff4 Mon Sep 17 00:00:00 2001 From: tsingbx Date: Tue, 30 Jul 2024 21:06:17 +0800 Subject: [PATCH 3/4] Remove redundant code and add examples --- _demo/cshademo/sha.go | 59 +++++++++++++++++++++++++++++++++++-------- c/openssl/sha1.go | 8 ++---- c/openssl/sha256.go | 8 ++---- c/openssl/sha512.go | 8 ++---- ssa/expr.go | 10 -------- 5 files changed, 55 insertions(+), 38 deletions(-) diff --git a/_demo/cshademo/sha.go b/_demo/cshademo/sha.go index ad58d8f8..37d2ad2b 100644 --- a/_demo/cshademo/sha.go +++ b/_demo/cshademo/sha.go @@ -8,22 +8,61 @@ import ( ) func main() { + str := "His money is twice tainted:" var sha1 openssl.SHA_CTX sha1.Init() - sha1.UpdateString("His money is twice tainted:") - sha1.UpdateString(" 'taint yours and 'taint mine.") + sha1.UpdateString(str) - h := make([]byte, openssl.SHA_DIGEST_LENGTH) - sha1.Final(unsafe.SliceData(h)) - fmt.Printf("%x\n", h) + h1 := make([]byte, openssl.SHA_DIGEST_LENGTH) + sha1.Final(unsafe.SliceData(h1)) + fmt.Printf("%x\n", h1) + + h2 := make([]byte, openssl.SHA_DIGEST_LENGTH) + openssl.SHA1String(str, unsafe.SliceData(h2)) + fmt.Printf("%x\n", h2) var sha256 openssl.SHA256_CTX sha256.Init() - sha256.UpdateString("His money is twice tainted:") - sha256.UpdateString(" 'taint yours and 'taint mine.") + sha256.UpdateString(str) + h3 := make([]byte, openssl.SHA256_DIGEST_LENGTH) + sha256.Final(unsafe.SliceData(h3)) + fmt.Printf("%x\n", h3) - hh := make([]byte, openssl.SHA256_DIGEST_LENGTH) - sha256.Final(unsafe.SliceData(hh)) - fmt.Printf("%x\n", hh) + h4 := make([]byte, openssl.SHA256_DIGEST_LENGTH) + openssl.SHA256String(str, unsafe.SliceData(h4)) + fmt.Printf("%x\n", h4) + + var sha512 openssl.SHA512_CTX + sha512.Init() + sha512.UpdateString("His money is twice tainted:") + + h5 := make([]byte, openssl.SHA512_DIGEST_LENGTH) + sha512.Final(unsafe.SliceData(h5)) + fmt.Printf("%x\n", h5) + + h6 := make([]byte, openssl.SHA512_DIGEST_LENGTH) + openssl.SHA512String(str, unsafe.SliceData(h6)) + fmt.Printf("%x\n", h6) + + var sha224 openssl.SHA256_CTX + sha224.Init224() + sha224.Update224String(str) + + h7 := make([]byte, openssl.SHA224_DIGEST_LENGTH) + sha224.Final224(unsafe.SliceData(h7)) + fmt.Printf("%x\n", h7) + h8 := make([]byte, openssl.SHA224_DIGEST_LENGTH) + openssl.SHA224String(str, unsafe.SliceData(h8)) + fmt.Printf("%x\n", h8) + + var sha384 openssl.SHA512_CTX + sha384.Init384() + sha384.Update384String(str) + h9 := make([]byte, openssl.SHA384_DIGEST_LENGTH) + sha384.Final384(unsafe.SliceData(h9)) + fmt.Printf("%x\n", h9) + h10 := make([]byte, openssl.SHA384_DIGEST_LENGTH) + openssl.SHA384String(str, unsafe.SliceData(h10)) + fmt.Printf("%x\n", h10) } diff --git a/c/openssl/sha1.go b/c/openssl/sha1.go index 6ca7f6b2..96da515d 100644 --- a/c/openssl/sha1.go +++ b/c/openssl/sha1.go @@ -42,12 +42,8 @@ func (c *SHA_CTX) Final(md *byte) c.Int { // OSSL_DEPRECATEDIN_3_0 void SHA1_Transform(SHA_CTX *c, const unsigned char *data); // -//go:linkname sha1Transform C.SHA1_Transform -func sha1Transform(c *SHA_CTX, data *byte) - -func (c *SHA_CTX) Transform(data *byte) { - sha1Transform(c, data) -} +// llgo:link (*SHA_CTX).Transform C.SHA1_Transform +func (c *SHA_CTX) Transform(data *byte) {} // unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md); // diff --git a/c/openssl/sha256.go b/c/openssl/sha256.go index d18e3a2d..0c41ddc5 100644 --- a/c/openssl/sha256.go +++ b/c/openssl/sha256.go @@ -69,12 +69,8 @@ func (c *SHA256_CTX) Final(md *byte) c.Int { // OSSL_DEPRECATEDIN_3_0 void SHA256_Transform(SHA256_CTX *c, const unsigned char *data); // -//go:linkname sha256Transform C.SHA256_Transform -func sha256Transform(c *SHA256_CTX, data *byte) - -func (c *SHA256_CTX) Transform(data *byte) { - sha256Transform(c, data) -} +// llgo:link (*SHA256_CTX).Transform C.SHA256_Transform +func (c *SHA256_CTX) Transform(data *byte) {} // unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md); // diff --git a/c/openssl/sha512.go b/c/openssl/sha512.go index 6add73b7..1e5c5b5b 100644 --- a/c/openssl/sha512.go +++ b/c/openssl/sha512.go @@ -67,12 +67,8 @@ func (c *SHA512_CTX) Final(md *byte) c.Int { // OSSL_DEPRECATEDIN_3_0 void SHA512_Transform(SHA512_CTX *c, const unsigned char *data); // -//go:linkname sha512Transform C.SHA512_Transform -func sha512Transform(c *SHA512_CTX, data *byte) - -func (c *SHA512_CTX) Transform(data *byte) { - sha512Transform(c, data) -} +// llgo:link (*SHA512_CTX).Transform C.SHA512_Transform +func (c *SHA512_CTX) Transform(data *byte) {} // unsigned char *SHA384(const unsigned char *d, size_t n, unsigned char *md); // diff --git a/ssa/expr.go b/ssa/expr.go index f9adbd7d..263ebb7a 100644 --- a/ssa/expr.go +++ b/ssa/expr.go @@ -1022,10 +1022,6 @@ func (b Builder) Do(da DoAction, fn Expr, args ...Expr) (ret Expr) { // Go spec (excluding "make" and "new"). func (b Builder) BuiltinCall(fn string, args ...Expr) (ret Expr) { switch fn { - case "max": - fallthrough - case "min": - return b.max(args...) case "len": if len(args) == 1 { arg := args[0] @@ -1132,12 +1128,6 @@ func (b Builder) BuiltinCall(fn string, args ...Expr) (ret Expr) { panic("todo: " + fn) } -// max return the max value for the args -func (b Builder) max(args ...Expr) (ret Expr) { - //todo - return args[len(args)-1] -} - // Println prints the arguments to stderr, followed by a newline. func (b Builder) Println(args ...Expr) (ret Expr) { return b.PrintEx(true, args...) From 95f64761ca424ee04e31ef2d2bf23e8a5813aa67 Mon Sep 17 00:00:00 2001 From: tsingbx Date: Tue, 30 Jul 2024 21:24:03 +0800 Subject: [PATCH 4/4] add SHA224_CTX, SHA384_CTX --- _demo/cshademo/sha.go | 16 ++++++++-------- c/openssl/sha256.go | 22 ++++++++++++---------- c/openssl/sha512.go | 22 ++++++++++++---------- 3 files changed, 32 insertions(+), 28 deletions(-) diff --git a/_demo/cshademo/sha.go b/_demo/cshademo/sha.go index 37d2ad2b..ee2577cb 100644 --- a/_demo/cshademo/sha.go +++ b/_demo/cshademo/sha.go @@ -45,22 +45,22 @@ func main() { openssl.SHA512String(str, unsafe.SliceData(h6)) fmt.Printf("%x\n", h6) - var sha224 openssl.SHA256_CTX - sha224.Init224() - sha224.Update224String(str) + var sha224 openssl.SHA224_CTX + sha224.Init() + sha224.UpdateString(str) h7 := make([]byte, openssl.SHA224_DIGEST_LENGTH) - sha224.Final224(unsafe.SliceData(h7)) + sha224.Final(unsafe.SliceData(h7)) fmt.Printf("%x\n", h7) h8 := make([]byte, openssl.SHA224_DIGEST_LENGTH) openssl.SHA224String(str, unsafe.SliceData(h8)) fmt.Printf("%x\n", h8) - var sha384 openssl.SHA512_CTX - sha384.Init384() - sha384.Update384String(str) + var sha384 openssl.SHA384_CTX + sha384.Init() + sha384.UpdateString(str) h9 := make([]byte, openssl.SHA384_DIGEST_LENGTH) - sha384.Final384(unsafe.SliceData(h9)) + sha384.Final(unsafe.SliceData(h9)) fmt.Printf("%x\n", h9) h10 := make([]byte, openssl.SHA384_DIGEST_LENGTH) openssl.SHA384String(str, unsafe.SliceData(h10)) diff --git a/c/openssl/sha256.go b/c/openssl/sha256.go index 0c41ddc5..2934208d 100644 --- a/c/openssl/sha256.go +++ b/c/openssl/sha256.go @@ -13,30 +13,32 @@ type SHA256_CTX struct { Num, MdLen c.Uint } +type SHA224_CTX SHA256_CTX + // OSSL_DEPRECATEDIN_3_0 int SHA224_Init(SHA256_CTX *c); // -// llgo:link (*SHA256_CTX).Init224 C.SHA224_Init -func (c *SHA256_CTX) Init224() c.Int { return 0 } +// llgo:link (*SHA224_CTX).Init C.SHA224_Init +func (c *SHA224_CTX) Init() c.Int { return 0 } // OSSL_DEPRECATEDIN_3_0 int SHA224_Update(SHA256_CTX *c, const void *data, size_t len); // -// llgo:link (*SHA256_CTX).Update224 C.SHA224_Update -func (c *SHA256_CTX) Update224(data unsafe.Pointer, n uintptr) c.Int { return 0 } +// llgo:link (*SHA224_CTX).Update C.SHA224_Update +func (c *SHA224_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 } -func (c *SHA256_CTX) Update224Bytes(data []byte) c.Int { - return c.Update224(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data))) +func (c *SHA224_CTX) UpdateBytes(data []byte) c.Int { + return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data))) } -func (c *SHA256_CTX) Update224String(data string) c.Int { - return c.Update224(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data))) +func (c *SHA224_CTX) UpdateString(data string) c.Int { + return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data))) } // OSSL_DEPRECATEDIN_3_0 int SHA224_Final(unsigned char *md, SHA256_CTX *c); // //go:linkname sha224Final C.SHA224_Final -func sha224Final(md *byte, c *SHA256_CTX) c.Int +func sha224Final(md *byte, c *SHA224_CTX) c.Int -func (c *SHA256_CTX) Final224(md *byte) c.Int { +func (c *SHA224_CTX) Final(md *byte) c.Int { return sha224Final(md, c) } diff --git a/c/openssl/sha512.go b/c/openssl/sha512.go index 1e5c5b5b..85431af8 100644 --- a/c/openssl/sha512.go +++ b/c/openssl/sha512.go @@ -13,30 +13,32 @@ type SHA512_CTX struct { Num, MdLen c.Uint } +type SHA384_CTX SHA512_CTX + // OSSL_DEPRECATEDIN_3_0 int SHA384_Init(SHA512_CTX *c); // -// llgo:link (*SHA512_CTX).Init384 C.SHA384_Init -func (c *SHA512_CTX) Init384() c.Int { return 0 } +// llgo:link (*SHA384_CTX).Init C.SHA384_Init +func (c *SHA384_CTX) Init() c.Int { return 0 } // OSSL_DEPRECATEDIN_3_0 int SHA384_Update(SHA512_CTX *c, const void *data, size_t len); // -// llgo:link (*SHA512_CTX).Update384 C.SHA384_Update -func (c *SHA512_CTX) Update384(data unsafe.Pointer, n uintptr) c.Int { return 0 } +// llgo:link (*SHA384_CTX).Update C.SHA384_Update +func (c *SHA384_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 } -func (c *SHA512_CTX) Update384Bytes(data []byte) c.Int { - return c.Update384(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data))) +func (c *SHA384_CTX) UpdateBytes(data []byte) c.Int { + return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data))) } -func (c *SHA512_CTX) Update384String(data string) c.Int { - return c.Update384(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data))) +func (c *SHA384_CTX) UpdateString(data string) c.Int { + return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data))) } // OSSL_DEPRECATEDIN_3_0 int SHA384_Final(unsigned char *md, SHA512_CTX *c); // //go:linkname sha384Final C.SHA384_Final -func sha384Final(md *byte, c *SHA512_CTX) c.Int +func sha384Final(md *byte, c *SHA384_CTX) c.Int -func (c *SHA512_CTX) Final384(md *byte) c.Int { +func (c *SHA384_CTX) Final(md *byte) c.Int { return sha384Final(md, c) }