Crate libsecret

source ·
Expand description

Rust Libsecret bindings

This library contains safe Rust bindings for Libsecret, a library that offers access to the Secret Service API.

See also

Usage

You can add libsecret by adding it in your Cargo.toml file:

[dependencies.secret]
package = "libsecret"
version = "0.x.y"

Define a password schema

Each stored password has a set of attributes which are later used to lookup the password. The names and types of the attributes are defined in a schema. The schema is usually defined once globally. Here’s how to define a schema:

let mut attributes = std::collections::HashMap::new();
attributes.insert("number", libsecret::SchemaAttributeType::Integer);
attributes.insert("string", libsecret::SchemaAttributeType::String);
attributes.insert("even", libsecret::SchemaAttributeType::Boolean);

let schema = libsecret::Schema::new("some.app.Id", libsecret::SchemaFlags::NONE, attributes);

Store a password

Each stored password has a set of attributes which are later used to lookup the password. The attributes should not contain secrets, as they are not stored in an encrypted fashion.

This first example stores a password asynchronously, and is appropriate for GUI applications so that the UI does not block.

let mut attributes = std::collections::HashMap::new();
attributes.insert("number", "8");
attributes.insert("string", "eight");
attributes.insert("even", "true");

let collection = libsecret::COLLECTION_DEFAULT;
libsecret::password_store_future(Some(&schema), attributes, Some(&collection), "The Label", "the password").await?;

Lookup a password

Each stored password has a set of attributes which are used to lookup the password. If multiple passwords match the lookup attributes, then the one stored most recently is returned.

This first example looks up a password asynchronously, and is appropriate for GUI applications so that the UI does not block.

let mut attributes = std::collections::HashMap::new();
attributes.insert("number", "8");
attributes.insert("even", "true");

let password = libsecret::password_lookup_future(Some(&schema), attributes).await?;

Remove a password

Each stored password has a set of attributes which are used to find which password to remove. If multiple passwords match the attributes, then the one stored most recently is removed.

This first example removes a password asynchronously, and is appropriate for GUI applications so that the UI does not block.

let mut attributes = std::collections::HashMap::new();
attributes.insert("number", "8");
attributes.insert("even", "true");

libsecret::password_clear_future(Some(&schema), attributes).await?;

Re-exports

Modules

Structs

  • Backend
    #SecretBackend represents a backend implementation of password storage.
  • Collection
    A proxy object representing a collection of secrets in the Secret Service.
  • CollectionCreateFlags
    Flags for create().
  • CollectionFlags
    Flags which determine which parts of the #SecretCollection proxy are initialized.
  • Item
    A secret item
  • ItemCreateFlags
    Flags for create().
  • ItemFlags
    Flags which determine which parts of the #SecretItem proxy are initialized.
  • Prompt
    A prompt in the Service
  • Retrievable
    A read-only view of a secret item in the Secret Service.
  • Schema
    Represents a set of attributes that are stored with an item.
  • SchemaAttribute
    An attribute in a #SecretSchema.
  • SchemaFlags
    Flags for a #SecretSchema definition.
  • SearchFlags
    Various flags to be used with ServiceExtManual::search() and Service::search_sync().
  • Service
    A proxy object representing the Secret Service.
  • ServiceFlags
    Flags which determine which parts of the #SecretService proxy are initialized during a get() or open() operation.
  • Value
    A value containing a secret

Enums

  • BackendFlags
    Flags which determine which parts of the #SecretBackend are initialized.
  • Error
    Errors returned by the Secret Service.
  • SchemaAttributeType
    The type of an attribute in a SecretSchema.
  • SchemaType
    Different types of schemas for storing secrets, intended for use with schema().

Statics

Functions