github.com/hechain20/hechain@v0.0.0-20220316014945-b544036ba106/bccsp/sw/mocks/mocks.go (about)

     1  /*
     2  Copyright hechain. 2022 All Rights Reserved.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8  		 http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package mocks
    18  
    19  import (
    20  	"errors"
    21  	"hash"
    22  	"reflect"
    23  
    24  	"github.com/hechain20/hechain/bccsp"
    25  )
    26  
    27  type Encryptor struct {
    28  	KeyArg       bccsp.Key
    29  	PlaintextArg []byte
    30  	OptsArg      bccsp.EncrypterOpts
    31  
    32  	EncValue []byte
    33  	EncErr   error
    34  }
    35  
    36  func (e *Encryptor) Encrypt(k bccsp.Key, plaintext []byte, opts bccsp.EncrypterOpts) (ciphertext []byte, err error) {
    37  	if !reflect.DeepEqual(e.KeyArg, k) {
    38  		return nil, errors.New("invalid key")
    39  	}
    40  	if !reflect.DeepEqual(e.PlaintextArg, plaintext) {
    41  		return nil, errors.New("invalid plaintext")
    42  	}
    43  	if !reflect.DeepEqual(e.OptsArg, opts) {
    44  		return nil, errors.New("invalid opts")
    45  	}
    46  
    47  	return e.EncValue, e.EncErr
    48  }
    49  
    50  type Decryptor struct{}
    51  
    52  func (*Decryptor) Decrypt(k bccsp.Key, ciphertext []byte, opts bccsp.DecrypterOpts) (plaintext []byte, err error) {
    53  	panic("implement me")
    54  }
    55  
    56  type Signer struct {
    57  	KeyArg    bccsp.Key
    58  	DigestArg []byte
    59  	OptsArg   bccsp.SignerOpts
    60  
    61  	Value []byte
    62  	Err   error
    63  }
    64  
    65  func (s *Signer) Sign(k bccsp.Key, digest []byte, opts bccsp.SignerOpts) (signature []byte, err error) {
    66  	if !reflect.DeepEqual(s.KeyArg, k) {
    67  		return nil, errors.New("invalid key")
    68  	}
    69  	if !reflect.DeepEqual(s.DigestArg, digest) {
    70  		return nil, errors.New("invalid digest")
    71  	}
    72  	if !reflect.DeepEqual(s.OptsArg, opts) {
    73  		return nil, errors.New("invalid opts")
    74  	}
    75  
    76  	return s.Value, s.Err
    77  }
    78  
    79  type Verifier struct {
    80  	KeyArg       bccsp.Key
    81  	SignatureArg []byte
    82  	DigestArg    []byte
    83  	OptsArg      bccsp.SignerOpts
    84  
    85  	Value bool
    86  	Err   error
    87  }
    88  
    89  func (s *Verifier) Verify(k bccsp.Key, signature, digest []byte, opts bccsp.SignerOpts) (valid bool, err error) {
    90  	if !reflect.DeepEqual(s.KeyArg, k) {
    91  		return false, errors.New("invalid key")
    92  	}
    93  	if !reflect.DeepEqual(s.SignatureArg, signature) {
    94  		return false, errors.New("invalid signature")
    95  	}
    96  	if !reflect.DeepEqual(s.DigestArg, digest) {
    97  		return false, errors.New("invalid digest")
    98  	}
    99  	if !reflect.DeepEqual(s.OptsArg, opts) {
   100  		return false, errors.New("invalid opts")
   101  	}
   102  
   103  	return s.Value, s.Err
   104  }
   105  
   106  type Hasher struct {
   107  	MsgArg  []byte
   108  	OptsArg bccsp.HashOpts
   109  
   110  	Value     []byte
   111  	ValueHash hash.Hash
   112  	Err       error
   113  }
   114  
   115  func (h *Hasher) Hash(msg []byte, opts bccsp.HashOpts) (hash []byte, err error) {
   116  	if !reflect.DeepEqual(h.MsgArg, msg) {
   117  		return nil, errors.New("invalid message")
   118  	}
   119  	if !reflect.DeepEqual(h.OptsArg, opts) {
   120  		return nil, errors.New("invalid opts")
   121  	}
   122  
   123  	return h.Value, h.Err
   124  }
   125  
   126  func (h *Hasher) GetHash(opts bccsp.HashOpts) (hash.Hash, error) {
   127  	if !reflect.DeepEqual(h.OptsArg, opts) {
   128  		return nil, errors.New("invalid opts")
   129  	}
   130  
   131  	return h.ValueHash, h.Err
   132  }
   133  
   134  type KeyGenerator struct {
   135  	OptsArg bccsp.KeyGenOpts
   136  
   137  	Value bccsp.Key
   138  	Err   error
   139  }
   140  
   141  func (kg *KeyGenerator) KeyGen(opts bccsp.KeyGenOpts) (k bccsp.Key, err error) {
   142  	if !reflect.DeepEqual(kg.OptsArg, opts) {
   143  		return nil, errors.New("invalid opts")
   144  	}
   145  
   146  	return kg.Value, kg.Err
   147  }
   148  
   149  type KeyDeriver struct {
   150  	KeyArg  bccsp.Key
   151  	OptsArg bccsp.KeyDerivOpts
   152  
   153  	Value bccsp.Key
   154  	Err   error
   155  }
   156  
   157  func (kd *KeyDeriver) KeyDeriv(k bccsp.Key, opts bccsp.KeyDerivOpts) (dk bccsp.Key, err error) {
   158  	if !reflect.DeepEqual(kd.KeyArg, k) {
   159  		return nil, errors.New("invalid key")
   160  	}
   161  	if !reflect.DeepEqual(kd.OptsArg, opts) {
   162  		return nil, errors.New("invalid opts")
   163  	}
   164  
   165  	return kd.Value, kd.Err
   166  }
   167  
   168  type KeyImporter struct {
   169  	RawArg  []byte
   170  	OptsArg bccsp.KeyImportOpts
   171  
   172  	Value bccsp.Key
   173  	Err   error
   174  }
   175  
   176  func (ki *KeyImporter) KeyImport(raw interface{}, opts bccsp.KeyImportOpts) (k bccsp.Key, err error) {
   177  	if !reflect.DeepEqual(ki.RawArg, raw) {
   178  		return nil, errors.New("invalid raw")
   179  	}
   180  	if !reflect.DeepEqual(ki.OptsArg, opts) {
   181  		return nil, errors.New("invalid opts")
   182  	}
   183  
   184  	return ki.Value, ki.Err
   185  }