image golang cacher

Dans la société moderne, la technologie numérique continue de se développer et la question de la protection des informations personnelles dans le monde en ligne est devenue de plus en plus importante. Afin de protéger la confidentialité des données, les utilisateurs recherchent diverses méthodes de cryptage, parmi lesquelles la technologie de masquage d'images est une méthode de cryptage courante. Golang, en tant que langage de programmation efficace, peut également être utilisé pour mettre en œuvre une technologie de masquage d'images.

Qu'est-ce que le masquage d'image ?

Le soi-disant masquage d'image consiste à masquer une autre image ou information dans une image, de sorte que les utilisateurs externes ne puissent voir que l'image externe et fermer les yeux sur l'image ou les informations cachées. Cette méthode peut bien protéger la confidentialité des données et améliorer la sécurité des données dans une certaine mesure.

Principe de masquage d'image de Golang

Golang, en tant que langage de programmation efficace, n'est pas seulement utilisé pour écrire des programmes back-end de sites Web. La bibliothèque de traitement d'image « image » de Golang fournit une multitude de fonctions de traitement d'image, qui peuvent effectuer diverses opérations de traitement sur les images, telles que le recadrage, la rotation, la mise à l'échelle, l'ajustement des couleurs, etc.

La technologie de masquage d'images intègre essentiellement une image dans une autre. Le processus d'intégration est divisé en deux étapes : tout d'abord, convertir l'image à masquer en chaîne binaire, puis intégrer la chaîne binaire dans l'image cible. Lors de l'intégration, nous pouvons utiliser les données de pixels de l'image cible comme support et stocker les informations à masquer dans certains bits des données de pixels en séquence. Ces informations cachées peuvent être une autre image, du texte, de l'audio, etc. Lorsque le destinataire obtient l’image, il peut décrypter les informations qui y sont cachées.

Masquer les images

Nous pouvons utiliser le package d'images fourni par Golang pour masquer les images. Voici les étapes à mettre en œuvre :

Étape 1 : Lire l'image cible

Utilisez la fonction Decode du package image de Golang pour décoder le fichier image en un objet Image dans le langage Go. Dans cet exemple, nous utiliserons cette fonction pour lire l'image cible.

func readImage(path string) (image.Image, error) {
    f, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer f.Close()
    
    img, _, err := image.Decode(f)
    if err != nil {
        return nil, err
    }
    
    return img, nil
}

Étape 2 : Convertir l'image à masquer en chaîne binaire

Nous pouvons utiliser la fonction ReadFile du package io/ioutil de Golang pour lire l'image à masquer et la convertir en chaîne binaire.

func readData(path string) ([]byte, error) {
    data, err := ioutil.ReadFile(path)
    if err != nil {
        return nil, err
    }
    
    return data, nil
}

Étape 3 : Masquer les données

Pour masquer les données binaires, nous devons créer un nouvel objet Image et modifier ses données de pixels. Puisque chaque pixel occupe généralement quatre octets (32 bits), nous pouvons utiliser le dernier bit de chaque pixel pour stocker des données. Par exemple, si la donnée à masquer est 01100101, on peut la stocker dans le pixel de l'image cible. La méthode spécifique consiste à mettre le dernier bit du pixel à 0 ou 1 pour stocker les données (car le dernier bit de). un pixel c'est un peu, donc un octet de données sur 8 pixels peut être stocké).

func hideData(img image.Image, data []byte) (image.Image, error) {
    bounds := img.Bounds()
    
    newImg := image.NewRGBA(bounds)
    
    idx := 0    
    var r, g, b, a uint32
    
    for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
        for x := bounds.Min.X; x < bounds.Max.X; x++ {
            r, g, b, a = img.At(x, y).RGBA()
            if idx < len(data)*8 {
                bitIdx := idx % 8
                bits := uint32(data[idx/8])
                mask := uint32(0x00 << bitIdx)
                if bits&(1<<7-bitIdx) > 0 {
                    mask |= uint32(0x01 << bitIdx)
                }
                r = (r & 0xFFFE) | (mask & 0x01)
                g = (g & 0xFFFE) | ((mask >> 1) & 0x01)
                b = (b & 0xFFFE) | ((mask >> 2) & 0x01)
                a = (a & 0xFFFE) | ((mask >> 3) & 0x01)                
            }
            newImg.Set(x, y, color.RGBA64{uint16(r), uint16(g), uint16(b), uint16(a)})
            idx++
        }
    }
    
    return newImg, nil
}

Étape 4 : Enregistrez la nouvelle image avec des données cachées

Pour enregistrer la nouvelle image avec des données cachées, utilisez la fonction Encode du package d'images de Golang.

func saveImage(path string, img image.Image) error {
    f, err := os.Create(path)
    if err != nil {
        return err
    }
    defer f.Close()
    
    err = png.Encode(f, img)
    if err != nil {
        return err
    }
    
    return nil
}

Code complet :

package main

import (
    "fmt"
    "image"
    "image/color"
    "image/png"
    "io/ioutil"
    "os"
)

func main() {
    if len(os.Args) < 2 {
        fmt.Println("usage: go run main.go [filename]")
        return
    }
    
    filename := os.Args[1]
    dataPath := "data.png"
    outputPath := "output.png"
    
    fmt.Printf("Reading target image %s...
", filename)
    img, err := readImage(filename)
    if err != nil {
        fmt.Println(err)
        return
    }
    
    fmt.Printf("Reading data image %s...
", dataPath)
    data, err := readData(dataPath)
    if err != nil {
        fmt.Println(err)
        return
    }
    
    fmt.Println("Hiding data...")
    newImg, err := hideData(img, data)
    if err != nil {
        fmt.Println(err)
        return
    }
    
    fmt.Printf("Saving image to %s...
", outputPath)
    err = saveImage(outputPath, newImg)
    if err != nil {
        fmt.Println(err)
        return
    }
    
    fmt.Println("Done!")
}

func readImage(path string) (image.Image, error) {
    f, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer f.Close()
    
    img, _, err := image.Decode(f)
    if err != nil {
        return nil, err
    }
    
    return img, nil
}

func readData(path string) ([]byte, error) {
    data, err := ioutil.ReadFile(path)
    if err != nil {
        return nil, err
    }
    
    return data, nil
}

func hideData(img image.Image, data []byte) (image.Image, error) {
    bounds := img.Bounds()
    
    newImg := image.NewRGBA(bounds)
    
    idx := 0    
    var r, g, b, a uint32
    
    for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
        for x := bounds.Min.X; x < bounds.Max.X; x++ {
            r, g, b, a = img.At(x, y).RGBA()
            if idx < len(data)*8 {
                bitIdx := idx % 8
                bits := uint32(data[idx/8])
                mask := uint32(0x00 << bitIdx)
                if bits&(1<<7-bitIdx) > 0 {
                    mask |= uint32(0x01 << bitIdx)
                }
                r = (r & 0xFFFE) | (mask & 0x01)
                g = (g & 0xFFFE) | ((mask >> 1) & 0x01)
                b = (b & 0xFFFE) | ((mask >> 2) & 0x01)
                a = (a & 0xFFFE) | ((mask >> 3) & 0x01)                
            }
            newImg.Set(x, y, color.RGBA64{uint16(r), uint16(g), uint16(b), uint16(a)})
            idx++
        }
    }
    
    return newImg, nil
}

func saveImage(path string, img image.Image) error {
    f, err := os.Create(path)
    if err != nil {
        return err
    }
    defer f.Close()
    
    err = png.Encode(f, img)
    if err != nil {
        return err
    }
    
    return nil
}

Ce qui précède sont les étapes et le code permettant à Golang de mettre en œuvre la technologie de masquage d'images. Il convient de noter que cette technologie de masquage d’images ne garantit pas totalement la sécurité des données, il s’agit simplement d’une méthode de cryptage. Si la confidentialité des données doit être protégée plus strictement, d’autres méthodes de cryptage doivent être envisagées.

Résumé

Golang est un langage de programmation efficace doté d'excellentes capacités de traitement d'images. Dans cet article, nous utilisons Golang pour mettre en œuvre une technologie de masquage d'images, qui peut garantir dans une certaine mesure la confidentialité des données. Il convient de noter que cette technologie ne garantit pas pleinement la sécurité des données. Par conséquent, dans les applications pratiques, davantage de méthodes de cryptage sont nécessaires pour protéger la confidentialité des données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!