Skip to content

Saac

stegobox.codec.Saac

Bases: BaseCodec

Saac is a steganography method for text.

Saac doesn't use any payload. It converts encrypted secret text into smooth statements that are difficult to detect abnormality.

Source code derived from: mickeysjm/StegaText

Source code in stegobox/codec/saac/saac.py 
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
class Saac(BaseCodec):
    """
    Saac is a steganography method for text.

    Saac doesn't use any payload. It converts encrypted secret text into smooth
    statements that are difficult to detect abnormality.

    Source code derived from:
    [mickeysjm/StegaText](https://github.com/mickeysjm/StegaText)
    """

    def __init__(self):
        self.temp = 1.0
        self.precision = 26
        self.topk = 50
        self.nucleus = 0.95
        self.enc, self.model, self.device = get_model()
        self.device = str(self.device)
        self.delta = 0.01
        if self.delta:
            self.nucleus = 2 ** (-1.0 * self.delta)

    def encode(self, carrier: str, payload=None) -> str:
        """encrypt secret plaintext to message bits & encode message bits to covertext

        Args:
            carrier: secret plaintext to send
            payload: should be kept as None

        Returns:
            covertext: covertext looks like normal text
        """

        plaintext = carrier
        message_ctx = [self.enc.encoder["<|endoftext|>"]]
        plaintext += "<eos>"
        message = decode_arithmetic(
            self.model,
            self.enc,
            plaintext,
            message_ctx,
            device=self.device,  # type: ignore
            precision=40,
            topk=60000,
        )

        context = ""
        context_tokens = encode_context(context, self.enc)

        out, nll, kl, words_per_bit, hq, topk_list, case_studies = encode_saac(
            self.model,
            self.enc,
            message,
            context_tokens,
            temp=self.temp,
            precision=self.precision,
            topk=self.topk,
            nucleus=self.nucleus,
            device=self.device,  # type: ignore
        )
        covertext = self.enc.decode(out)
        return covertext

    def decode(self, carrier: str) -> str:
        """decode covertext to message bits & map message bits back to original text

        Args:
            carrier: received covertext

        Returns:
            reconst: recovered plaintext
        """
        covertext = carrier
        context = ""
        context_tokens = encode_context(context, self.enc)
        message_rec = decode_saac(
            self.model,
            self.enc,
            covertext,
            context_tokens,
            temp=self.temp,
            precision=self.precision,
            topk=self.topk,
            nucleus=self.nucleus,
            device=self.device,  # type: ignore
        )
        message_ctx = [self.enc.encoder["<|endoftext|>"]]
        reconst = encode_arithmetic(
            self.model,
            self.enc,
            message_rec,
            message_ctx,
            device=self.device,  # type: ignore
            precision=40,
            topk=60000,
        )
        reconst = self.enc.decode(reconst[0])
        return reconst

encode(carrier, payload=None)

encrypt secret plaintext to message bits & encode message bits to covertext

Parameters:

Name Type Description Default
carrier str

secret plaintext to send

 required
payload

should be kept as None

 None

Returns:

Name Type Description
covertext str

covertext looks like normal text
Source code in stegobox/codec/saac/saac.py 
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
def encode(self, carrier: str, payload=None) -> str:
    """encrypt secret plaintext to message bits & encode message bits to covertext

    Args:
        carrier: secret plaintext to send
        payload: should be kept as None

    Returns:
        covertext: covertext looks like normal text
    """

    plaintext = carrier
    message_ctx = [self.enc.encoder["<|endoftext|>"]]
    plaintext += "<eos>"
    message = decode_arithmetic(
        self.model,
        self.enc,
        plaintext,
        message_ctx,
        device=self.device,  # type: ignore
        precision=40,
        topk=60000,
    )

    context = ""
    context_tokens = encode_context(context, self.enc)

    out, nll, kl, words_per_bit, hq, topk_list, case_studies = encode_saac(
        self.model,
        self.enc,
        message,
        context_tokens,
        temp=self.temp,
        precision=self.precision,
        topk=self.topk,
        nucleus=self.nucleus,
        device=self.device,  # type: ignore
    )
    covertext = self.enc.decode(out)
    return covertext

decode(carrier)

decode covertext to message bits & map message bits back to original text

Parameters:

Name Type Description Default
carrier str

received covertext

 required

Returns:

Name Type Description
reconst str

recovered plaintext
Source code in stegobox/codec/saac/saac.py 
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
def decode(self, carrier: str) -> str:
    """decode covertext to message bits & map message bits back to original text

    Args:
        carrier: received covertext

    Returns:
        reconst: recovered plaintext
    """
    covertext = carrier
    context = ""
    context_tokens = encode_context(context, self.enc)
    message_rec = decode_saac(
        self.model,
        self.enc,
        covertext,
        context_tokens,
        temp=self.temp,
        precision=self.precision,
        topk=self.topk,
        nucleus=self.nucleus,
        device=self.device,  # type: ignore
    )
    message_ctx = [self.enc.encoder["<|endoftext|>"]]
    reconst = encode_arithmetic(
        self.model,
        self.enc,
        message_rec,
        message_ctx,
        device=self.device,  # type: ignore
        precision=40,
        topk=60000,
    )
    reconst = self.enc.decode(reconst[0])
    return reconst