3760981038

Committed 22 Dec 2022 08:35PM UTC coverage: 79.498%. First build

Build Type

push

github

Committed by Bartek

Commit Message

Basic test for the static_datastore binary

Run Details

919 of 1156 relevant lines covered (79.5%)

0.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

74.58

/blenc/datastore.go

package blenc

import (
        "context"
        "crypto/aes"
        "crypto/sha256"
        "io"

        "github.com/cinode/go/common"
        "github.com/cinode/go/datastore"
        "github.com/cinode/go/internal/blobtypes/generation"
        "github.com/cinode/go/internal/utilities/securefifo"
)

// FromDatastore creates Blob Encoder using given datastore implementation as
// the storage layer
func FromDatastore(ds datastore.DS) BE {
        return &beDatastore{ds: ds}
}

type beDatastore struct {
        ds datastore.DS
}

func (be *beDatastore) Read(ctx context.Context, name common.BlobName, ki KeyInfo, w io.Writer) error {
        // TODO: Some analysis of the data from blob types ?
        // In case of dynamic link we'll have to skip link's additional data

        cw, err := streamCipherWriterForKeyInfo(ki, w)
        if err != nil {
                return err
        }

        err = be.ds.Read(ctx, name, cw)
        if err != nil {
                return err
        }
        return nil
}

func (be *beDatastore) Create(ctx context.Context, blobType common.BlobType, r io.Reader) (common.BlobName, KeyInfo, WriterInfo, error) {

        handler, err := generation.HandlerForType(blobType)
        if err != nil {
                return nil, nil, nil, err
        }

        ki, rClone, err := be.generateKeyInfo(r)
        if err != nil {
                return nil, nil, nil, err
        }
        defer rClone.Close()

        tempWriteBuffer, err := securefifo.New()
        if err != nil {
                return nil, nil, nil, err
        }
        defer tempWriteBuffer.Close()

        // Encrypt data with calculated key
        encWriter, err := streamCipherWriterForKeyInfo(ki, tempWriteBuffer)
        if err != nil {
                return nil, nil, nil, err
        }

        _, err = io.Copy(encWriter, rClone)
        if err != nil {
                return nil, nil, nil, err
        }

        encReader, err := tempWriteBuffer.Done()
        if err != nil {
                return nil, nil, nil, err
        }
        defer encReader.Close()

        // Generate new blob info
        hash, wi, err := handler.PrepareNewBlob(encReader)
        if err != nil {
                return nil, nil, nil, err
        }

        name, err := common.BlobNameFromHashAndType(hash, blobType)
        if err != nil {
                return nil, nil, nil, err
        }

        // Store encrypted blob into the datastore
        encReader, err = encReader.Reset()
        if err != nil {
                return nil, nil, nil, err
        }
        defer encReader.Close()

        err = be.ds.Update(ctx, name, encReader)
        if err != nil {
                return nil, nil, nil, err
        }

        return name, ki, wi, nil
}

func (be *beDatastore) generateKeyInfo(r io.Reader) (KeyInfo, io.ReadCloser, error) {

        w, err := securefifo.New()
        if err != nil {
                return nil, nil, err
        }
        defer w.Close()

        // TODO: This should be a part of internal/blobtypes/generation

        // TODO: Those values MUST be checked when reading the blob
        //       to ensure that those can not be weakened on purpose

        // hasher for key
        hasher := sha256.New()
        hasher.Write([]byte{0x00})

        // hasher for IV
        hasher2 := sha256.New()
        hasher2.Write([]byte{0xFF})

        // Copy to temporary fifo and calculate hash at the same time
        _, err = io.Copy(
                w,
                io.TeeReader(io.TeeReader(r, hasher), hasher2),
        )
        if err != nil {
                return nil, nil, err
        }

        hash := hasher.Sum(nil)
        hash2 := hasher2.Sum(nil)

        ki := &keyInfoStatic{
                t:   keyTypeAES,
                key: hash[:keySizeAES],
                iv:  hash2[:aes.BlockSize],
        }

        reader, err := w.Done()
        if err != nil {
                return nil, nil, err
        }

        return ki, reader, nil

}

func (be *beDatastore) Exists(ctx context.Context, name common.BlobName) (bool, error) {
        return be.ds.Exists(ctx, name)
}

func (be *beDatastore) Delete(ctx context.Context, name common.BlobName) error {
        return be.ds.Delete(ctx, name)
}

1	package blenc
2
3	import (
4	"context"
5	"crypto/aes"
6	"crypto/sha256"
7	"io"
8
9	"github.com/cinode/go/common"
10	"github.com/cinode/go/datastore"
11	"github.com/cinode/go/internal/blobtypes/generation"
12	"github.com/cinode/go/internal/utilities/securefifo"
13	)
14
15	// FromDatastore creates Blob Encoder using given datastore implementation as
16	// the storage layer
17	func FromDatastore(ds datastore.DS) BE {	1✔
18	return &beDatastore{ds: ds}	1✔
19	}	1✔
20
21	type beDatastore struct {
22	ds datastore.DS
23	}
24
25	func (be *beDatastore) Read(ctx context.Context, name common.BlobName, ki KeyInfo, w io.Writer) error {	1✔
26	// TODO: Some analysis of the data from blob types ?	1✔
27	// In case of dynamic link we'll have to skip link's additional data	1✔
28		1✔
29	cw, err := streamCipherWriterForKeyInfo(ki, w)	1✔
30	if err != nil {	1✔
31	return err	×
32	}	×
33
34	err = be.ds.Read(ctx, name, cw)	1✔
35	if err != nil {	1✔
36	return err	×
37	}	×
38	return nil	1✔
39	}
40
41	func (be *beDatastore) Create(ctx context.Context, blobType common.BlobType, r io.Reader) (common.BlobName, KeyInfo, WriterInfo, error) {	1✔
42		1✔
43	handler, err := generation.HandlerForType(blobType)	1✔
44	if err != nil {	1✔
45	return nil, nil, nil, err	×
46	}	×
47
48	ki, rClone, err := be.generateKeyInfo(r)	1✔
49	if err != nil {	1✔
50	return nil, nil, nil, err	×
51	}	×
52	defer rClone.Close()	1✔
53		1✔
54	tempWriteBuffer, err := securefifo.New()	1✔
55	if err != nil {	1✔
56	return nil, nil, nil, err	×
57	}	×
58	defer tempWriteBuffer.Close()	1✔
59		1✔
60	// Encrypt data with calculated key	1✔
61	encWriter, err := streamCipherWriterForKeyInfo(ki, tempWriteBuffer)	1✔
62	if err != nil {	1✔
63	return nil, nil, nil, err	×
64	}	×
65
66	_, err = io.Copy(encWriter, rClone)	1✔
67	if err != nil {	1✔
68	return nil, nil, nil, err	×
69	}	×
70
71	encReader, err := tempWriteBuffer.Done()	1✔
72	if err != nil {	1✔
73	return nil, nil, nil, err	×
74	}	×
75	defer encReader.Close()	1✔
76		1✔
77	// Generate new blob info	1✔
78	hash, wi, err := handler.PrepareNewBlob(encReader)	1✔
79	if err != nil {	1✔
80	return nil, nil, nil, err	×
81	}	×
82
83	name, err := common.BlobNameFromHashAndType(hash, blobType)	1✔
84	if err != nil {	1✔
85	return nil, nil, nil, err	×
86	}	×
87
88	// Store encrypted blob into the datastore
89	encReader, err = encReader.Reset()	1✔
90	if err != nil {	1✔
91	return nil, nil, nil, err	×
92	}	×
93	defer encReader.Close()	1✔
94		1✔
95	err = be.ds.Update(ctx, name, encReader)	1✔
96	if err != nil {	1✔
97	return nil, nil, nil, err	×
98	}	×
99
100	return name, ki, wi, nil	1✔
101	}
102
103	func (be *beDatastore) generateKeyInfo(r io.Reader) (KeyInfo, io.ReadCloser, error) {	1✔
104		1✔
105	w, err := securefifo.New()	1✔
106	if err != nil {	1✔
107	return nil, nil, err	×
108	}	×
109	defer w.Close()	1✔
110		1✔
111	// TODO: This should be a part of internal/blobtypes/generation	1✔
112		1✔
113	// TODO: Those values MUST be checked when reading the blob	1✔
114	// to ensure that those can not be weakened on purpose	1✔
115		1✔
116	// hasher for key	1✔
117	hasher := sha256.New()	1✔
118	hasher.Write([]byte{0x00})	1✔
119		1✔
120	// hasher for IV	1✔
121	hasher2 := sha256.New()	1✔
122	hasher2.Write([]byte{0xFF})	1✔
123		1✔
124	// Copy to temporary fifo and calculate hash at the same time	1✔
125	_, err = io.Copy(	1✔
126	w,	1✔
127	io.TeeReader(io.TeeReader(r, hasher), hasher2),	1✔
128	)	1✔
129	if err != nil {	1✔
130	return nil, nil, err	×
131	}	×
132
133	hash := hasher.Sum(nil)	1✔
134	hash2 := hasher2.Sum(nil)	1✔
135		1✔
136	ki := &keyInfoStatic{	1✔
137	t: keyTypeAES,	1✔
138	key: hash[:keySizeAES],	1✔
139	iv: hash2[:aes.BlockSize],	1✔
140	}	1✔
141		1✔
142	reader, err := w.Done()	1✔
143	if err != nil {	1✔
144	return nil, nil, err	×
145	}	×
146
147	return ki, reader, nil	1✔
148
149	}
150
151	func (be *beDatastore) Exists(ctx context.Context, name common.BlobName) (bool, error) {	1✔
152	return be.ds.Exists(ctx, name)	1✔
153	}	1✔
154
155	func (be *beDatastore) Delete(ctx context.Context, name common.BlobName) error {	1✔
156	return be.ds.Delete(ctx, name)	1✔
157	}	1✔

cinode / go / 3760981038

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous