開発者用SDK
Keeperシークレットマネージャー用のサンプルコードとSDKの実装ガイド

概要
KeeperシークレットマネージャーSDKは、すべての主要なプログラミング言語からシークレット管理機能にシンプル・高速・効率的にアクセスできるよう特別に設計されています。
インストール
Mavenのスナップショットリポジトリを参照
repositories {
mavenCentral()
maven { url
"https://s01.oss.sonatype.org/content/groups/public/" }
}
プロジェクトに以下の依存関係を追加
com.keepersecurity.secrets-manager:core:16.6.4
mavenのスナップショットリポジトリを参照
repositories {
mavenCentral()
maven("https://s01.oss.sonatype.org/content/groups/public/")
}
プロジェクトに以下の依存関係を追加
com.keepersecurity.secrets-manager:core:16.0.1-SNAPSHOT
npm install @keeper-security/secrets-manager-core
pip3 install -U keeper-secrets-manager-coredotnet add package Keeper.SecretsManager
import (
ksm "github.com/keeper-security/secrets-manager-go/core"
klog "github.com/keeper-security/secrets-manager-go/core/logger"
)cargo add keeper-secrets-manager-core認証
シークレットマネージャーSDKは、ボルトへの認証にワンタイムアクセストークンまたはローカル構成ファイル内の生成済みキーのいずれかを使用します。 コマンダーCLIでワンタイムアクセストークンを1つまたは複数生成するには、secrets-manager client add コマンドを使用します。
$ keeper shell
... login ...
My Vault> secrets-manager client add --app MyApplication --unlock-ip初期化
シークレットマネージャーSDKは、接続トークンや設定情報を保持するために構成ファイルを使用します。以下のコード例は、シークレットマネージャーSDKとワンタイムアクセストークンを使用して設定ファイルを作成します。
import com.keepersecurity.secretsManager.core.*;
import static com.keepersecurity.secretsManager.core.SecretsManager.*;
public class KSMSample {
public static void main(String[] args){
// oneTimeTokenはストレージの初期化に一度だけ使用
// 初回実行以降の呼び出しでは、ksm-config.jsonを使用
String oneTimeToken = "[ONE TIME TOKEN]";
KeyValueStorage storage = new LocalConfigStorage("ksm-config.json");
try {
// 初回の実行後、この行は削除可能
initializeStorage(storage, oneTimeToken);
SecretsManagerOptions options = new SecretsManagerOptions(storage);
} catch (Exception e) {
System.out.println(e.getMessage());
}
// `options`を使用する他のコード
}
}const {
getSecrets,
initializeStorage,
localConfigStorage,
downloadFile,
updateSecret
} = require('@keeper-security/secrets-manager-core')
const oneTimeToken = '[One Time Access Token]'
const getKeeperRecords = async () => {
const storage = localConfigStorage("ksm-config.json")
await initializeStorage(storage, oneTimeToken)
const {records} = await getSecrets({storage: storage})
console.log(records)
const firstRecord = records[0]
const firstRecordPassword = firstRecord.data.fields.find(x => x.type === 'password')
console.log(firstRecordPassword.value[0])
}
getKeeperRecords().finally()from keeper_secrets_manager_core import SecretsManager
from keeper_secrets_manager_core.storage import FileKeyValueStorage
oneTimeToken = "[One Time Access Token]"
secrets_manager = SecretsManager(
# ワンタイムトークンは一度しか使用できません - 以後は、生成された設定ファイルを使用します
token=oneTimeToken,
config=FileKeyValueStorage('ksm-config.json')
)
# すべてのパスワードレコードを取得(設定も初期化)
records = secrets_manager.get_secrets()
using System;
using SecretsManager;
var oneTimeToken = "[One Time Access Token]";
var storage = new LocalConfigStorage("ksm-config.json");
try {
// ワンタイムトークンは一度しか使用できません - 以後は、生成された設定ファイルを使用します
SecretsManagerClient.InitializeStorage(storage, oneTimeToken);
var options = new SecretsManagerOptions(storage);
// すべてのパスワードレコードを取得(設定も初期化)
var records = (await SecretsManagerClient.GetSecrets(options)).Records;
Console.WriteLine($"Received {records.Length} record(s)");
// 最初のレコードからパスワードを取得
var firstRecord = records[0];
var password = records[0].FieldValue("password").ToString();
Console.WriteLine($"Password: {password}");
} catch (Exception e) {
Console.WriteLine(e);
}package main
// Secrets Managerのインポート
import ksm "github.com/keeper-security/secrets-manager-go/core"
func main() {
onetimeAccessCode := "[One Time Access Token]"
options := &ksm.ClientOptions{
// ワンタイムトークンは一度しか使用できません - 以後は、生成された設定ファイルを使用します
Token: onetimeAccessCode,
Config: ksm.NewFileKeyValueStorage("ksm-config.json")}
sm := ksm.NewSecretsManager(options)
// すべてのパスワードレコードを取得(設定も初期化)
allRecords, _ := sm.GetSecrets([]string{})
// 最初のレコードからパスワードを取得:
firstRecord := allRecords[0]
firstRecordPassword := firstRecord.Password()
print("Password: [", firstRecordPassword, "]")
}use keeper_secrets_manager_core::{
core::{ClientOptions, SecretsManager},
custom_error::KSMRError,
storage::FileKeyValueStorage,
};
fn main() -> Result<(), KSMRError> {
// ワンタイムトークンを指定
let token = "<Your One time token>".to_string();
// シークレット情報を保存するファイルを指定 (ここでは test.json)
let file_name = FileKeyValueStorage::new_config_storage("test.json".to_string())?;
// クライアントオプションを作成
let client_options = ClientOptions::new_client_options(token, file_name);
// Secrets Manager クライアントを初期化
let mut secrets_manager = SecretsManager::new(client_options)?;
// シークレットを取得
let secrets = secrets_manager.get_secrets(Vec::new())?;
// シークレットを出力
for secret in secrets {
secret.print();
println!("---");
}
Ok(())
}構成ファイルを初期化した後、ワンタイムアクセストークンはコードから削除しておきます。
この初期化コードでは、以下のキーを含むJSON構成ファイルがデバイスのローカルストレージに作成されます。
キー
説明
hostname
自社テナントが配置されている宛先ホスト:
keepersecurity.com
keepersecurity.eu
keepersecurity.com.au
govcloud.keepersecurity.us
clientID
ハッシュ化されたclientKey、ここでclientKeyはクライアントデバイスの一意の識別子
privateKey
クライアントデバイスの秘密鍵
serverPublicKeyId
Keeperインフラストラクチャの公開鍵のID
appKey
アプリケーションの秘密鍵
appOwnerPublicKey
アプリケーション所有者の公開鍵
以下は生成された構成ファイルの例です。
{
"hostname": "keepersecurity.com",
"clientId": "ab2x3z/Acz0QFTiilm8UxIlqNLlNa25KMj=TpOqznwa4Si-h9tY7n3zvFwlXXDoVWkIs3xrMjcLGwgu3ilmq7Q==",
"privateKey":"MLSHAgABCDEFGyqGSM49AEGCCqGSM49AwEHBG0wawIWALTARgmcnWx/DH+r7cKh4kokasdasdaDbvHmLABstNbqDwaCWhRANCAARjunta9SJdZE/LVXfVb22lpIfK4YMkJEDaFMOAyoBt0BrQ8aEhvrHN5/Z1BgZ/WpDm9dMR7E5ASIQuYUiAw0t9",
"serverPublicKeyId":"10",
"appKey":"RzhSIyKxbpjNu045TUrKaNREYIns+Hk9Kn8YtT+CtK0=",
"appOwnerPublicKey":"Sq1W1OAnTwi8V/Vs/lhsin2sfSoaRfOwwDDBqoP+EO9bsBMWCzQdl9ClauDiKLXGmlmyx2xmSAdH+hlxvBRs6kU="
}構成ファイル作成のその他の方法については、構成ファイルのページをご参照ください。
すべてのシークレットを取得
import com.keepersecurity.secretsManager.core.*;
import static com.keepersecurity.secretsManager.core.SecretsManager.*;
import java.io.FileOutputStream;
public class KSMSample {
public static void main(String[] args){
// 事前に初期化されたストレージを取得
KeyValueStorage storage = new LocalConfigStorage("ksm-config.json");
try {
SecretsManagerOptions options = new SecretsManagerOptions(storage);
// 使用可能なすべてのシークレットを取得
KeeperSecrets secrets = SecretsManager.getSecrets(options);
// レコードの詳細を出力
System.out.println(secrets.getRecords());
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}const {
getSecrets,
initializeStorage,
localConfigStorage,
downloadFile,
updateSecret
} = require('@keeper-security/secrets-manager-core')
const oneTimeToken = '[One Time Access Token]'
const getKeeperRecords = async () => {
const storage = localConfigStorage("ksm-config.json")
await initializeStorage(storage, oneTimeToken)
const {records} = await getSecrets({storage: storage})
}
getKeeperRecords().finally()from keeper_secrets_manager_core import SecretsManager
from keeper_secrets_manager_core.storage import FileKeyValueStorage
secrets_manager = SecretsManager(
config=FileKeyValueStorage('ksm-config.json')
)
all_records = secrets_manager.get_secrets()
# すべてのレコードのJSONデータを出力
for record in all_records:
# record.print () # 記録をSTDOUTに出力
print(record.uid + " - " + record.title)
print("\tLogin: " + record.field('login')[0])
print("\tPassword: " + record.field('password')[0])
using System;
using System.Threading.Tasks;
using SecretsManager;
private static async Task retrieveAllSecrets()
{
// 事前に初期化されたストレージを取得
var storage = new LocalConfigStorage("ksm-config.json");
var options = new SecretsManagerOptions(storage);
// 使用可能なすべてのシークレットを取得
var records = (await SecretsManagerClient.GetSecrets(options)).Records;
foreach (var record in records)
{
Console.WriteLine(record.RecordUid + " - " + record.Data.title);
foreach (var field in record.Data.fields)
{
Console.WriteLine("\t" + field.label + " (" + field.type + "): [" + String.Join(", ", field.value) + "]");
}
}
}package main
// Secrets Managerのインポート
import ksm "github.com/keeper-security/secrets-manager-go/core"
func main() {
options := &ksm.ClientOptions{
// ワンタイムトークンは一度しか使用できません - 以後は、生成された設定ファイルを使用します
Config: ksm.NewFileKeyValueStorage("ksm-config.json")}
sm := ksm.NewSecretsManager(options)
// すべてのパスワードレコードを取得(設定も初期化)
allRecords, _ := sm.GetSecrets([]string{})
for _, record := range allRecords {
println("UID", record.Uid, ", title [", record.Title(), "]")
}
}use keeper_secrets_manager_core::{core::{ClientOptions, SecretsManager}, custom_error::KSMRError, storage::FileKeyValueStorage};
fn main()-> Result<(), KSMRError>{
let token = "<Your One time token>".to_string();
let file_name = FileKeyValueStorage::new_config_storage("test.json".to_string())?;
let client_options = ClientOptions::new_client_options(token, file_name);
let mut secrets_manager = SecretsManager::new(client_options)?;
let secrets = secrets_manager.get_secrets(Vec::new())?;
for secret in secrets {
secret.print();
println!("---");
}
Ok(())
}個々のシークレットを取得
レコードタイトルでシークレットを取得
import com.keepersecurity.secretsManager.core.*;
import java.util.List;
public class KSMSample {
public static void main(String[] args){
// 事前に初期化されたストレージを取得
KeyValueStorage storage = new LocalConfigStorage("ksm-config.json");
try {
SecretsManagerOptions options = new SecretsManagerOptions(storage);
// 取得するレコードのタイトル
String recordTitle = "My Credentials";
// タイトルでレコードを検索
KeeperRecord myCredentials = secrets.getRecords().getSecretByTitle(recordTitle);
// レコードの詳細を出力
System.out.println("Record UID: " + myCredentials.getRecordUid());
System.out.println("Title: " + myCredentials.getData().getTitle());
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}const {
getSecretByTitle,
localConfigStorage,
} = require('@keeper-security/secrets-manager-core')
const getKeeperRecord = async () => {
const options = { storage: localConfigStorage("ksm-config.json")
const {myCredential} = await getSecretByTitle(options, "My Credential")
}
getKeeperRecord().finally()from keeper_secrets_manager_core import SecretsManager
from keeper_secrets_manager_core.storage import FileKeyValueStorage
secrets_manager = SecretsManager(
config=FileKeyValueStorage('ksm-config.json')
)
record_title = "My Record"
record = secrets_manager.get_secret_by_title(record_title)
if record:
print(record.uid + " - " + record.title)
print("\tLogin: " + record.field('login')[0])
print("\tPassword: " + record.field('password')[0])
else:
print("No record found with title: " + record_title)using System;
using System.Threading.Tasks;
using SecretsManager;
private static async Task getOneIndividualSecret()
{
var storage = new LocalConfigStorage("ksm-config.json");
var options = new SecretsManagerOptions(storage);
var records = (await SecretsManagerClient.GetSecretsByTitle(
options, "My Credentials")
).Records;
foreach (var record in records)
{
Console.WriteLine(record.RecordUid + " - " + record.Data.title);
foreach (var field in record.Data.fields)
{
Console.WriteLine("\t" + field.label + " (" + field.type + "): [" + String.Join(", ", field.value) + "]");
}
}
}package main
// シークレットマネージャーのインポート
import ksm "github.com/keeper-security/secrets-manager-go/core"
func main() {
options := &ksm.ClientOptions{
// ワンタイムトークンは一度しか使用できません - 以後は、生成された設定ファイルを使用します
Config: ksm.NewFileKeyValueStorage("ksm-config.json")}
sm := ksm.NewSecretsManager(options)
// タイトルで個々のレコードを取得
allRecords, _ := ksm.GetSecretsByTitle("My Credentials")
for _, record := range allRecords {
println("UID", record.Uid, ", title [", record.Title(), "]")
}
}package main
// Import Secrets Manager
import ksm "github.com/keeper-security/secrets-manager-go/core"
func main() {
options := &ksm.ClientOptions{
// One time tokens can be used only once - afterwards use the generated config file
Config: ksm.NewFileKeyValueStorage("ksm-config.json")}
sm := ksm.NewSecretsManager(options)
// Retrieve one individual record by Title
allRecords, _ := ksm.GetSecretsByTitle("My Credentials")
for _, record := range allRecords {
println("UID", record.Uid, ", title [", record.Title(), "]")
}
}レコードUIDでシークレットを取得
この例では、レコードUIDはXXXになっています。
import com.keepersecurity.secretsManager.core.*;
import java.util.List;
public class KSMSample {
public static void main(String[] args){
// 事前に初期化されたストレージを取得
KeyValueStorage storage = new LocalConfigStorage("ksm-config.json");
try {
SecretsManagerOptions options = new SecretsManagerOptions(storage);
// 必要なレコードのUIDを含むフィルタを作成
List<String> uidFilter = List.of("[XXX]");
// フィルタを使用してシークレットを取得
KeeperSecrets secrets = SecretsManager.getSecrets(options, uidFilter);
// 取得結果から目的のシークレットを取得
KeeperRecord myCredentials = secrets.getRecords().get(0);
// レコードの詳細を出力
System.out.println("Record UID: " + myCredentials.getRecordUid());
System.out.println("Title: " + myCredentials.getData().getTitle());
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}const {
getSecretsByTitle,
localConfigStorage,
} = require('@keeper-security/secrets-manager-core')
const oneTimeToken = '[One Time Access Token]'
const getKeeperRecord = async () => {
const options = { storage: localConfigStorage("config.json")
const {myCredential} = await getSecrets(options, ["XXX"]
}
getKeeperRecord().finally()from keeper_secrets_manager_core import SecretsManager
from keeper_secrets_manager_core.storage import FileKeyValueStorage
secrets_manager = SecretsManager(
config=FileKeyValueStorage('ksm-config.json')
)
UID_FILTER = ['RECORD_UID']
record = secrets_manager.get_secrets(UID_FILTER)[0]
print(record.uid + " - " + record.title)
print("\tLogin: " + record.field('login')[0])
print("\tPassword: " + record.field('password')[0])
シークレットを取得すると、シークレットから個々のフィールドを取得できます。
# 標準テンプレートフィールドを取得
login = record.field('login', single=True)
# APIキーなどのカスタムフィールドを取得
api_key = record.custom_field('API Key', single=True)using System;
using System.Threading.Tasks;
using SecretsManager;
private static async Task getOneIndividualSecret()
{
var storage = new LocalConfigStorage("ksm-config.json");
var options = new SecretsManagerOptions(storage);
var records = (await SecretsManagerClient.GetSecrets(
options, new[] { "XXX" })
).Records;
foreach (var record in records)
{
Console.WriteLine(record.RecordUid + " - " + record.Data.title);
foreach (var field in record.Data.fields)
{
Console.WriteLine("\t" + field.label + " (" + field.type + "): [" + String.Join(", ", field.value) + "]");
}
}
}package main
// Secrets Managerのインポート
import ksm "github.com/keeper-security/secrets-manager-go/core"
func main() {
options := &ksm.ClientOptions{
// ワンタイムトークンは一度しか使用できません - 以後は、生成された設定ファイルを使用します
Config: ksm.NewFileKeyValueStorage("ksm-config.json")}
sm := ksm.NewSecretsManager(options)
// UIDで個々のレコードを取得(設定も初期化)
allRecords, _ := sm.GetSecrets([]string{"[Record UID]"})
for _, record := range allRecords {
println("UID", record.Uid, ", title [", record.Title(), "]")
}
} use keeper_secrets_manager_core::{
core::{ClientOptions, SecretsManager},
storage::InMemoryKeyValueStorage,
custom_error::KSMRError
};
fn main()-> Result<(), KSMRError>{
// setup secrets manager
let config_string = "your_base64_goes_here".to_string();
let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
let client_options = ClientOptions::new_client_options(config);
let mut secrets_manager = SecretsManager::new(client_options)?;
let uids = vec!["record_1_uid".to_string(), "record_2_uid".to_string()];
// get filtered records
let filtered_secrets = secrets_manager.get_secrets(uids)?;
// print out filtered records
for secret in filtered_secrets{
secret.print();
}
Ok(())
} パスワードを取得
個々のレコードのパスワードフィールドを取得する例。
この例では、レコードUIDはXXXになっています。
import com.keepersecurity.secretsManager.core.*;
import java.util.List;
public class KSMSample {
public static void main(String[] args){
// 事前に初期化されたストレージを取得
KeyValueStorage storage = new LocalConfigStorage("ksm-config.json");
try {
SecretsManagerOptions options = new SecretsManagerOptions(storage);
// 必要なレコードのUIDを含むフィルタを作成
List<String> uidFilter = List.of("XXX");
// フィルタを使用してシークレットを取得
KeeperSecrets secrets = SecretsManager.getSecrets(options, uidFilter);
// 取得結果から目的のシークレットを取得
KeeperRecord myCredentials = secrets.getRecords().get(0);
// パスワードを取得して出力
String pwd = myCredentials.getPassword();
System.out.println("Password from Keeper: " + pwd);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}secret.data.fields.find(x => x.type === 'password')from keeper_secrets_manager_core import SecretsManager
from keeper_secrets_manager_core.storage import FileKeyValueStorage
secrets_manager = SecretsManager(
config=FileKeyValueStorage('ksm-config.json')
)
# UIDで個々のシークレットを取得
UID_FILTER = 'XXX'
secret = secrets_manager.get_secrets([UID_FILTER])[0]
# シークレットからパスワードを取得
secret.field('password', single=True)using System;
using System.Threading.Tasks;
using SecretsManager;
private static async Task retrieveAPassword()
{
var storage = new LocalConfigStorage("ksm-config.json");
var options = new SecretsManagerOptions(storage);
var records = (await SecretsManagerClient.GetSecrets(
options, new[] { "XXX" })
).Records;
foreach (var record in records)
{
// 「password」フィールドを取得
var passwordVal = record.FieldValue("password");
Console.WriteLine(record.RecordUid + " - " + record.Data.title + " - password=[" + passwordVal + "]");
}
}package main
// Secrets Managerのインポート
import ksm "github.com/keeper-security/secrets-manager-go/core"
func main() {
options := &ksm.ClientOptions{
// ワンタイムトークンは一度しか使用できません - 以後は、生成された設定ファイルを使用します
Config: ksm.NewFileKeyValueStorage("ksm-config.json")}
sm := ksm.NewSecretsManager(options)
// すべてのレコードを取得(設定も初期化)
allRecords, _ := sm.GetSecrets([]string{})
for _, record := range allRecords {
passwordMethod1 := record.Password()
//passwordMethod2 := record.GetFieldValueByType("password") // フィールドにアクセスしてパスワードを取得
println("UID", record.Uid, ", Password [", passwordMethod1, "]")
}
}use keeper_secrets_manager_core::{core::{ClientOptions, SecretsManager}, custom_error::KSMRError, storage::FileKeyValueStorage,enums::StandardFieldTypeEnum};
fn main()-> Result<(), KSMRError>{
let token = "<Your One time token>".to_string();
let file_name = FileKeyValueStorage::new_config_storage("test.json".to_string())?;
let client_options = ClientOptions::new_client_options(token, file_name);
let mut secrets_manager = SecretsManager::new(client_options)?;
let records_filter = Vec::new(); // add record filters of needed based on UID
let secrets = secrets_manager.get_secrets(records_filter)?;
for secret in secrets {
let standard_field = secret.get_standard_field_value(StandardFieldTypeEnum::PASSWORD.get_type(),false)?;
println!("name : {}", standard_field);
println!("---");
}
Ok(())
}添付ファイルのダウンロード
import com.keepersecurity.secretsManager.core.*;
import java.io.FileOutputStream;
import java.util.List;
public class KSMSample {
public static void main(String[] args){
// 事前に初期化されたストレージを取得
KeyValueStorage storage = new LocalConfigStorage("ksm-config.json");
try {
SecretsManagerOptions options = new SecretsManagerOptions(storage);
// 必要なレコードのUIDを含むフィルタを作成
List<String> uidFilter = List.of("XXX");
// フィルタを使用してシークレットを取得
KeeperSecrets secrets = SecretsManager.getSecrets(options, uidFilter);
// 取得結果から目的のシークレットを取得
KeeperRecord myCredentials = secrets.getRecords().get(0);
// レコードからファイル名によるファイル参照を取得
KeeperFile file = myCredentials.getFileByName("acme.cer");
// ファイルをダウンロード
byte[] fileBytes = SecretsManager.downloadFile(file);
String filename = file.getData().getName();
FileOutputStream fos = new FileOutputStream(filename);
fos.write(fileBytes);
System.out.println("Downloaded File: " + filename);
} catch (Exception e) {
System.out.println("KSM ran into an problem: " + e.getMessage());
}
}
}const file = firstRecord.files.find(x => x.data.name === 'acme.cer')
if (file) {
const fileBytes = await downloadFile(file)
fs.writeFileSync(file.data.name, fileBytes)
}from keeper_secrets_manager_core import SecretsManager
from keeper_secrets_manager_core.storage import FileKeyValueStorage
secrets_manager = SecretsManager(
config=FileKeyValueStorage('ksm-config.json')
)
# UIDで個々のシークレットを取得
UID_FILTER = 'XXX'
secret = secrets_manager.get_secrets([UID_FILTER])[0]
# すべてのファイルを/tmpフォルダに保存(存在しない場合はフォルダを作成)
for file in secret.files:
print("file: %s" % file)
file.save_file("/tmp/" + file.name, True)using System;
using System.IO;
using System.Threading.Tasks;
using SecretsManager;
private static async Task downloadAFileAttachment()
{
var storage = new LocalConfigStorage("ksm-config.json");
var options = new SecretsManagerOptions(storage);
// UIDでレコードを取得
var records = (await SecretsManagerClient.GetSecrets(
options, new[] { "XXX" })
).Records;
foreach (var record in records)
{
// 最初のレコードからファイルをダウンロード
var file = record.GetFileByName("acme.cer");
if (file != null)
{
var fileBytes = SecretsManagerClient.DownloadFile(file);
// ディスクにバイトを書き込む
await File.WriteAllBytesAsync(file.Data.name, fileBytes);
}
}
}package main
// Secrets Managerのインポート
import ksm "github.com/keeper-security/secrets-manager-go/core"
func main() {
options := &ksm.ClientOptions{
// ワンタイムトークンは一度しか使用できません - 以後は、生成された設定ファイルを使用します
Config: ksm.NewFileKeyValueStorage("ksm-config.json")}
sm := ksm.NewSecretsManager(options)
// すべてのパスワードレコードを取得(設定も初期化)
allRecords, _ := sm.GetSecrets([]string{"[Record UID]"})
for _, record := range allRecords {
// タイトルでファイルを検索
file := record.FindFileByTitle("[FILE TITLE]")
// 配列からインデックスでファイルを取得
//file := record.Files[0]
// ファイルをディスクに保存
file.SaveFile("/tmp/"+file.Name, true)
}
}use keeper_secrets_manager_core::{core::{ClientOptions, SecretsManager}, custom_error::KSMRError, storage::FileKeyValueStorage};
fn main()-> Result<(), KSMRError>{
let token = "<Your One time token>".to_string();
let file_name = FileKeyValueStorage::new_config_storage("test.json".to_string())?;
let client_options = ClientOptions::new_client_options(token, file_name);
let mut secrets_manager = SecretsManager::new(client_options)?;
let records_filter = Vec::new(); // add record filters of needed based on UID
let secrets = secrets_manager.get_secrets(records_filter)?;
for secret in secrets {
secret.download_file("file_name", "file_name_to_be_created_along_with_path")?; //secret.download("dummyy.txt","./dummy2.txt"); -> something like this
println!("---");
}
Ok(())
}添付ファイルのアップロード
import com.keepersecurity.secretsManager.core.*;
import java.io.File;
import java.io.FileInputStream;
import java.util.Arrays;
public class KSMSample {
public static void main(String[] args){
// 事前に初期化されたストレージを取得
KeyValueStorage storage = new LocalConfigStorage("ksm-config.json");
try {
SecretsManagerOptions options = new SecretsManagerOptions(storage);
// 必要なレコードのUIDを含むフィルタを作成
List<String> uidFilter = List.of("XXX");
// フィルタを使用してシークレットを取得
KeeperSecrets secrets = SecretsManager.getSecrets(options, uidFilter);
// ファイルのアップロード先のシークレットを取得
KeeperRecord ownerRecord = secrets.getRecords().get(0);
// アップロードするファイルからバイトを取得
File file = new File("./myFile.json");
FileInputStream fl = new FileInputStream(file);
byte[] fileBytes = new byte[(int)file.length()];
fl.read(fileBytes);
fl.close();
// アップロードするKeeperファイルを作成
KeeperFileUpload myFile = new KeeperFileUpload(
"myFile.json",
"My File",
"application/json",
fileBytes
);
// 選択したレコードにファイルをアップロード
SecretsManager.uploadFile(options, ownerRecord, myFile);
} catch (Exception e) {
System.out.println("KSM ran into an problem: " + e.getMessage());
}
}
}import * as fs from "fs";
import {getSecrets, uploadFile} from "@keeper-security/secrets-manager-core";
// ファイルを添付するレコードを取得
const {records} = await getSecrets({storage: storage}, ['XXX'])
const ownerRecord = records[0]
// アップロードするファイルデータを取得
const fileData = fs.readFileSync('./assets/my-file.json')
// 選択したレコードにファイルをアップロード
await uploadFile(options, ownerRecord, {
name: 'my-file.json',
title:'Sample File',
type: 'application/json',
data: fileData
})from keeper_secrets_manager_core import SecretsManager
from keeper_secrets_manager_core.storage import FileKeyValueStorage
from keeper_secrets_manager_core.core import KeeperFileUpload
secrets_manager = SecretsManager(
config=FileKeyValueStorage('ksm-config.json')
)
# UIDによって個々のシークレットを取得し、ファイルを添付
UID_FILTER = 'XXX'
owner_record= secrets_manager.get_secrets([UID_FILTER])[0]
# アップロード用のファイルデータを準備
my_file = KeeperFileUpload.from_file("./myFile.json", "myfile.json", "My File")
# 所有者のレコードに添付されたファイルをアップロード
upload_file(owner_record, file: my_file)
using System;
using System.IO;
using System.Threading.Tasks;
using SecretsManager;
private static async Task uploadFile()
{
// ストレージとオプションを初期化
var storage = new LocalConfigStorage("ksm-config.json");
var options = new SecretsManagerOptions(storage);
// ファイルを添付するレコードを取得
var records = (await SecretsManagerClient.GetSecrets(
options, new[] { "XXX" })
).Records;
var ownerRecord = records[0];
// アップロードするファイルデータを取得
var bytes = await File.ReadAllBytesAsync("my-file.json");
var myFile = new KeeperFileUpload(
"my-file1.json",
"My File",
null,
bytes
);
// 選択したレコードにファイルをアップロード
await SecretsManagerClient.UploadFile(options, firstRecord, myFile);
}package main
// Secrets Managerのインポート
import ksm "github.com/keeper-security/secrets-manager-go/core"
func main() {
options := &ksm.ClientOptions{
// ワンタイムトークンは一度しか使用できません - 以後は、生成された設定ファイルを使用します
Config: ksm.NewFileKeyValueStorage("ksm-config.json")}
sm := ksm.NewSecretsManager(options)
// ファイルをアップロードするレコードを取得
allRecords, _ := sm.GetSecrets([]string{"[Record UID]"})
ownerRecord := allRecords[0]
// ファイルのデータを取得してアップロードを準備
dat, err := ioutil.ReadFile("/myFile.json")
var myFile := KeeperFileUpload{
Name: "myFile.json",
Title:"My File",
Type: "application/json",
Data: dat
}
// 選択したレコードにファイルをアップロード
sm.UploadFile(ownerRecord, myFile)
}use keeper_secrets_manager_core::{core::{ClientOptions, SecretsManager}, custom_error::KSMRError, storage::FileKeyValueStorage};
fn main()-> Result<(), KSMRError>{
let token = "<Your One time token>".to_string();
let file_name = FileKeyValueStorage::new_config_storage("test.json".to_string())?;
let client_options = ClientOptions::new_client_options(token, file_name);
println!("Delete Secrets --------------------------------------------------------------");
let mut secrets_manager_3 = SecretsManager::new(client_options)?;
let uids = vec!["<secret uid>".to_string()];
let secrets_records_3 = secrets_manager_3.get_secrets(uids.clone())?;
for secret in secret_records3{
let keeper_file = KeeperFileUpload::get_file_for_upload(
"./dummy2222.txt", Some("test1_file.txt"), None,None
)?;
let upload_status = secrets_manager.upload_file(secret, keeper_file)?;
println!("upload status: {}", upload_status);
}
Ok(())
}TOTPコードを取得
import com.keepersecurity.secretsManager.core.*;
public class KSMSample {
public static void main(String[] args){
// 事前に初期化されたストレージを取得
KeyValueStorage storage = new LocalConfigStorage("ksm-config.json");
try {
SecretsManagerOptions options = new SecretsManagerOptions(storage);
// シークレットを取得
KeeperSecrets secrets = SecretsManager.getSecrets(options);
// 目的のシークレットからtotp urlを取得
String totpUrl = Notation.getValue(secrets, "XXX/field/oneTimeCode");
// TOTPコードを取得
TotpCode totpCode = TotpCode.uriToTotpCode(totpUrl);
System.out.println("TOTP: " + totpCode.getCode());
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}const url = getValue(secrets, `keeper://${record.recordUid}/field/oneTimeCode`)
let totp = await getTotpCode(url)from keeper_secrets_manager_core import SecretsManager
from keeper_secrets_manager_core.storage import FileKeyValueStorage
# TOTPユーティリティのインポート
from keeper_secrets_manager_core.utils import get_totp_code
secrets_manager = SecretsManager(
config=FileKeyValueStorage('ksm-config.json')
)
# UIDで個々のシークレットを取得
UID_FILTER = 'XXX'
secret = secrets_manager.get_secrets([UID_FILTER])[0]
# シークレットからTOTP URLを取得
url = secret.get_standard_field_value('oneTimeCode', True)
# シークレットのTOTPフィールドからワンタイムトークンを取得
code, _, _ = get_totp_code(url)using System;
using System.Threading.Tasks;
using SecretsManager;
private static async Task retrieveTOTPCodes()
{
var storage = new LocalConfigStorage("ksm-config.json");
var options = new SecretsManagerOptions(storage);
// UIDでレコードを取得
var records = (await SecretsManagerClient.GetSecrets(
options, new[] { "XXX" })
).Records;
foreach (var record in records)
{
// レコードからQR/TOTPコードを取得
string totpUrl = record.FieldValue("oneTimeCode").ToString();
// KSM組み込み関数を使用してTOTP URIを変換
var totp = CryptoUtils.GetTotpCode(totpUrl);
Console.WriteLine("QR Code: [" + totp.Code + "]");
Console.WriteLine("Expire in: [" + totp.TimeLeft + "]");
Console.WriteLine("Total time interval: [" + totp.Period + "]");
}
}package main
// シークレットマネージャーのインポート
import ksm "github.com/keeper-security/secrets-manager-go/core"
func main() {
options := &ksm.ClientOptions{
// ワンタイムトークンは一度しか使用できません - 以後は、生成された設定ファイルを使用します
Config: ksm.NewFileKeyValueStorage("ksm-config.json")}
sm := ksm.NewSecretsManager(options)
// すべてのパスワードレコードを取得(設定も初期化)
allRecords, _ := sm.GetSecrets([]string{"[Record UID]"})
for _, record := range allRecords {
totpUrl := record.GetFieldValueByType("oneTimeCode")
totpCode, _ := ksm.GetTotpCode(totpUrl)
println("QR Code: [", totpCode.Code, "]")
println("Expire in: [", totpCode.TimeLeft, "]")
println("Total time interval: [", totpCode.Period, "]")
}
}
use keeper_secrets_manager_core::{core::{ClientOptions, SecretsManager}, custom_error::KSMRError, enums::StandardFieldTypeEnum, storage::FileKeyValueStorage};
use std::{collections::HashMap, fs::File, io::Write};
use serde_json;
fn main()-> Result<(), KSMRError>{
let token = "<token>".to_string();
let file_name = FileKeyValueStorage::new_config_storage("test.json".to_string())?;
let client_options = ClientOptions::new_client_options(token, file_name);
let mut secrets_manager = SecretsManager::new(client_options)?;
let mut uids = Vec::new();
uids.push("<secret uid>".to_string());
// get_secrets
let secrets_records = secrets_manager.get_secrets(uids.clone())?;
for mut secret in secrets_records {
let value = secret.get_standard_field_value(StandardFieldTypeEnum::ONETIMECODE.get_type(),false)?;
let url = utils::get_otp_url_from_value_obj(value)?;
let totp_code = utils::get_totp_code(&url)?;
println!("{}", totp_code.get_code());
}
Ok(())
}
パスワードの更新
import com.keepersecurity.secretsManager.core.*;
import java.util.List;
public class KSMSample {
public static void main(String[] args){
// 事前に初期化されたストレージを取得
KeyValueStorage storage = new LocalConfigStorage("ksm-config.json");
try {
SecretsManagerOptions options = new SecretsManagerOptions(storage);
// 必要なレコードのUIDを含むフィルタを作成
List<String> uidFilter = List.of("XXX");
// フィルタを使用してシークレットを取得
KeeperSecrets secrets = SecretsManager.getSecrets(options, uidFilter);
// 取得結果から目的のシークレットを取得
KeeperRecord myCredentials = secrets.getRecords().get(0);
// パスワードを更新し、変更をレコードに保存
myCredentials.updatePassword("aP1$t367QOCvL$eM$bG#");
SecretsManager.updateSecret(options, myCredentials);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}// 最初のレコードのパスワードを更新
firstRecordPassword.value[0] = 'aP1$t367QOCvL$eM$bG#'
await updateSecret({storage: storage}, firstRecord)from keeper_secrets_manager_core import SecretsManager
from keeper_secrets_manager_core.storage import FileKeyValueStorage
secrets_manager = SecretsManager(
config=FileKeyValueStorage('ksm-config.json')
)
# UIDで個々のシークレットを取得
UID_FILTER = ['XXX']
record = secrets_manager.get_secrets(UID_FILTER)[0]
# 新しいパスワードをシークレットに設定
record.set_standard_field_value('password', 'NewPassword123')
# シークレットの変更をKeeperボルトに保存
secrets_manager.save(record)
using System.Threading.Tasks;
using SecretsManager;
private static async Task updateAPassword()
{
var storage = new LocalConfigStorage("ksm-config.json");
var options = new SecretsManagerOptions(storage);
var records = (await SecretsManagerClient.GetSecrets(
options, new[] { "XXX" })
).Records;
foreach (var record in records)
{
// 「password」フィールドに新しい値を設定
record.UpdateFieldValue("password", "NewP4$$w0Rd");
// フィールドの新しい値をKeeperバックエンドに反映
await SecretsManagerClient.UpdateSecret(options, record);
}
}package main
// シークレットマネージャーのインポート
import ksm "github.com/keeper-security/secrets-manager-go/core"
func main() {
options := &ksm.ClientOptions{
// ワンタイムトークンは一度しか使用できません - 以後は、生成された設定ファイルを使用します
Config: ksm.NewFileKeyValueStorage("ksm-config.json")}
sm := ksm.NewSecretsManager(options)
// すべてのパスワードレコードを取得(設定も初期化)
allRecords, _ := sm.GetSecrets([]string{"[Record UID]"})
for _, record := range allRecords {
record.SetPassword("NewP4$$w0Rd") // 新しいパスワードをシークレットに設定
record.RawJson = ksm.DictToJson(record.RecordDict) // JSONをサーバーに送信するため設定が必要
sm.Save(record) // シークレットの変更をKeeperボルトに保存
}
}use keeper_secrets_manager_core::{core::{ClientOptions, SecretsManager}, custom_error::KSMRError, enums::StandardFieldTypeEnum, storage::FileKeyValueStorage};
use std::{collections::HashMap, fs::File, io::Write};
use serde_json;
fn main()-> Result<(), KSMRError>{
let token = "<token>".to_string();
let file_name = FileKeyValueStorage::new_config_storage("test.json".to_string())?;
let client_options = ClientOptions::new_client_options(token, file_name);
let mut secrets_manager = SecretsManager::new(client_options)?;
let mut uids = Vec::new();
uids.push("<secret uid>".to_string());
// get_secrets
let secrets_records = secrets_manager.get_secrets(uids.clone())?;
for mut secret in secrets_records {
let field_type= StandardFieldTypeEnum::PASSWORD.get_type();
secret_to_update.set_standard_field_value_mut(field_type, "some_new_password".into())?
}
Ok(())
}パスワードの生成
import com.keepersecurity.secretsManager.core.*;
import java.util.List;
import java.util.Arrays;
public class KSMSample {
public static void main(String[] args){
// 事前に初期化されたストレージを取得
KeyValueStorage storage = new LocalConfigStorage("ksm-config.json");
try {
SecretsManagerOptions options = new SecretsManagerOptions(storage);
// 必要なレコードのUIDを含むフィルタを作成
List<String> uidFilter = Arrays.asList("XXX");
// フィルタを使用してシークレットを取得
KeeperSecrets secrets = SecretsManager.getSecrets(options, uidFilter);
// 取得結果から目的のシークレットを取得
KeeperRecord myCredentials = secrets.getRecords().get(0);
// 新しいパスワードを作成
String password = CryptoUtils.generatePassword();
// 新しいパスワードをレコードに設定
myCredentials.updatePassword(password);
// パスワードをKeeperに保存
SecretsManager.updateSecret(options, myCredentials);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}// ランダムなパスワードを生成
let password = await generatePassword()
// 最初のレコードのパスワードを更新
firstRecordPassword.value[0] = password
await updateSecret({storage: storage}, firstRecord)from keeper_secrets_manager_core import SecretsManager
from keeper_secrets_manager_core.storage import FileKeyValueStorage
# ユーティリティからgenerate_passwordをインポート
from keeper_secrets_manager_core.utils import generate_password
secrets_manager = SecretsManager(
config=FileKeyValueStorage('ksm-config.json')
)
# UIDで個々のシークレットを取得
UID_FILTER = ['XXX']
secret = secrets_manager.get_secrets(UID_FILTER)[0]
# ランダムなパスワードを生成
password = generate_password()
# 新しいパスワードをシークレットに設定
record.set_standard_field_value('password', password)
# シークレットの変更をKeeperボルトに保存
secrets_manager.save(record)using System.Threading.Tasks;
using SecretsManager;
private static async Task generateNewPassword()
{
var storage = new LocalConfigStorage("ksm-config.json");
var options = new SecretsManagerOptions(storage);
var records = (await SecretsManagerClient.GetSecrets(
options, new[] { "XXX" })
).Records;
foreach (var record in records)
{
// 新しいランダムなパスワードを生成
var password = CryptoUtils.GeneratePassword();
// 「password」フィールドに新しい値を設定
record.UpdateFieldValue("password", password);
// フィールドの新しい値をKeeperバックエンドに反映
await SecretsManagerClient.UpdateSecret(options, record);
}
}package main
// シークレットマネージャーのインポート
import ksm "github.com/keeper-security/secrets-manager-go/core"
func main() {
options := &ksm.ClientOptions{
// ワンタイムトークンは一度しか使用できません - 以後は、生成された設定ファイルを使用します
Config: ksm.NewFileKeyValueStorage("ksm-config.json")}
sm := ksm.NewSecretsManager(options)
// すべてのパスワードレコードを取得(設定も初期化)
allRecords, _ := sm.GetSecrets([]string{"[Record UID]"})
for _, record := range allRecords {
newPassword, _ := ksm.GeneratePassword(64, 10, 10, 10, 10) // 新しいランダムなパスワードを生成
record.SetPassword(newPassword) // 新しいパスワードをシークレットに設定
sm.Save(record) // シークレットの変更をKeeperボルトに保存
}
}use keeper_secrets_manager_core::{custom_error::KSMRError, utils::{generate_password_with_options, PasswordOptions}};
fn main()-> Result<(), KSMRError>{
let password_options = PasswordOptions::new();
let charset = "~".to_string();
let password_options = password_options.length(34).digits(5).lowercase(5).uppercase(7).special_characters(5).special_characterset(charset);
let password = generate_password_with_options(password_options)?;
println!("Password: {}", password);
Ok(())
}シークレットの作成
シークレットマネージャーSDKでは、Keeperのボルト内にレコードを作成することができます。
レコードを作成するには、シークレットマネージャーアプリケーションがアクセスできる共有フォルダのUIDが必要です。また、その共有フォルダ内での編集権限を持っている必要があり、そのフォルダ内に既存のレコードが1件以上存在している必要もあります。新しいレコードは、そのフォルダ内に作成されます。
以下の例では、[FOLDER UID]を対象の共有フォルダのUIDに置き換えてください。
import com.keepersecurity.secretsManager.core.*;
import java.util.List;
public class KSMSample {
// 新しいレコードが格納されるフォルダ
static String folderUid = "[FOLDER UID]";
public static void addLoginRecord(){
LocalConfigStorage storage = new LocalConfigStorage("ksm-config.txt");
SecretsManagerOptions options = new SecretsManagerOptions(storage);
KeeperSecrets secrets = SecretsManager.getSecrets(options);
KeeperRecordData newRecordData = new KeeperRecordData(
"Sample Example KSM Record",
"login",
List.of(
new Login("[email protected]"),
new Password("Pa$$word123")
),
null,
"\tThis record was created\n\tvia KSM Documentation Java Example"
);
SecretsManager.createSecret(options, folderUid, newRecordData, secrets);
}
public static void main(String[] args) {
addLoginRecord();
}
}// ログインのレコードとフィールドを作成
let newRec = {
"title":"My JavaScript Record 1",
"type": "login",
"fields": [
{
"type": "login", "value": [ "My Username" ]
},
{
"type": "password", "value": [ await generatePassword() ]
}
],
"notes":"This record was createdvia KSM"
}
// 新しいレコードをKeeperボルトに保存
let newRecUid = await createSecret(options, "[FOLDER UID]", newRec)from keeper_secrets_manager_core import SecretsManager
from keeper_secrets_manager_core.storage import FileKeyValueStorage
# RecordCreateメソッドのインポート
from keeper_secrets_manager_core.dto.dtos import RecordCreate
# 新しいログインレコードを作成
new_login_record = RecordCreate('login', "Sample KSM Record")
# ログインフィールドとパスワードフィールドに入力
new_login_record.fields = [
RecordField(field_type='login', value='[email protected]'),
RecordField(field_type='password', value=generate_password())
]
# メモに入力
new_login_record.notes = 'This is a Python record creation example'
# 新しいレコードを作成
secrets_manager.create_secret('[FOLDER UID]', new_login_record)using System;
using System.Threading.Tasks;
using SecretsManager;
private static async Task createASecret()
{
var folderUid = "[FOLDER UID]";
var storage = new LocalConfigStorage("ksm-config.json");
var options = new SecretsManagerOptions(storage);
// 新しいログインレコードを作成
var newRecord = new KeeperRecordData();
newRecord.type = "login";
newRecord.title = "Sample KSM Record from Docs Example (C#)";
// レコードフィールドに値を入力
newRecord.fields = new[]
{
new KeeperRecordField { type = "login", value = new[] { "[email protected]" } },
new KeeperRecordField { type = "password", value = new[] { CryptoUtils.GeneratePassword() } },
};
// レコードのメモに入力
newRecord.notes = "This record was created via KSM .NET Example";
// 新しいレコードをKeeperボルトに保存
var recordUid = await SecretsManagerClient.CreateSecret(options, folderUid, newRecord);
Console.WriteLine("New record UID = [" + recordUid + "]");
}package main
// Secrets Managerのインポート
import ksm "github.com/keeper-security/secrets-manager-go/core"
func main() {
folderUid := "[FOLDER UID]"
options := &ksm.ClientOptions{
// ワンタイムトークンは一度しか使用できません - 以後は、生成された設定ファイルを使用します
Config: ksm.NewFileKeyValueStorage("ksm-config.json")}
sm := ksm.NewSecretsManager(options)
// 新しいログインレコードを作成
newLoginRecord := ksm.NewRecordCreate("login", "Sample KSM Record from Docs Example (GoLang)")
// ログインフィールドとパスワードフィールドに入力
password, _ := ksm.GeneratePassword(32, 0, 0, 0, 0)
newLoginRecord.Fields = append(newLoginRecord.Fields,
ksm.NewLogin("[email protected]"),
ksm.NewPassword(password))
// メモに入力
newLoginRecord.Notes = "This record was created via KSM GoLang Example"
// 新しいレコードをKeeperボルトに保存
recordUid, _ := sm.CreateSecretWithRecordData("", folderUid, newLoginRecord)
println("New record UID = [", recordUid, "]")
}use keeper_secrets_manager_core::{
core::{ClientOptions, SecretsManager},
custom_error::KSMRError,
dto::{
dtos::{RecordCreate},
field_structs::{self},
},
enums::{DefaultRecordType},
storage::FileKeyValueStorage,
utils::{self},
};
use log::error;
use tracing::{info};
fn main()-> Result<(), KSMRError>{
let token = "<Your One time token>".to_string();
let file_name = FileKeyValueStorage::new_config_storage("test.json".to_string())?;
let client_options = ClientOptions::new_client_options(token, file_name);
println!("Create Secret\n--------------------------------------------------------------");
let mut secrets_manager_3 = SecretsManager::new(client_options)?;
let mut new_record = RecordCreate::new(
DefaultRecordType::Login.get_type().to_string(),
"sample create record".to_string(),
None,
);
let login_field = field_structs::Login::new(
"[email protected]".to_string(),
None,
Some(false),
Some(false),
);
new_record.append_standard_fields(login_field);
let password_field = field_structs::Password::new(
"Dummy_Password#123".to_string(),
None,
Some(true),
Some(false),
Some(true),
None,
)?;
new_record.append_standard_fields(password_field);
let created_record: Result<String, KSMRError> =
secrets_manager.create_secret("<folder_uid>".to_string(), new_record);
match created_record {
Ok(data) => {
info!("created_record uid: {}", data);
data
}
Err(err) => {
error!("Error creating record: {}", err);
return Err(err);
}
};
Ok(())
}use keeper_secrets_manager_core::{
core::{ClientOptions, SecretsManager},
storage::InMemoryKeyValueStorage,
dto::{dtos::RecordCreate, field_structs::RecordField}
};
use serde_json::{self, json, Number, Value};
fn main()-> Result<(), KSMRError>{
// setup secrets manager
let config_string = "your_base64_goes_here".to_string();
let config = InMemoryKeyValueStorage::new_config_storage(Some(config_string))?;
let client_options = ClientOptions::new_client_options(config);
let mut secrets_manager = SecretsManager::new(client_options)?;
// This is how we create a Record
let mut created_record = RecordCreate::new("login".to_string(), "Login Record RUST_LOG_TEST".to_string(), Some("Dummy Notes".to_string()));
// This is how we create a single field
let password_field = RecordField::new_record_field_with_options("password".to_string(), Value::String(utils::generate_password()?), Some("Random password label".to_string()), false, true);
// This is one of the ways to create a value object from JSON String
let security_question_value = Value::from_str("{\"question\": \"What is the question?\", \"answer\": \"This is the answer!\"}")?;
//This is one way to create all fields directly in a vector
let fields = vec![
RecordField::new_record_field("login".to_string(), Value::String("[email protected]".to_string()), Some("My Custom Login lbl".to_string())),
RecordField::new_record_field("login".to_string(), Value::String("[email protected]".to_string()), Some("My Label".to_string())),
password_field,
RecordField::new_record_field("securityQuestion".to_string(),security_question_value , Some("My Label".to_string())),
RecordField::new_record_field("multiline".to_string(),Value::String("This\nIs a multiline\nnote".to_string()) , Some("My Multiline lbl".to_string())),
RecordField::new_record_field("secret".to_string(),Value::String("SecretText".to_string()) , Some("My Hidden Field lbl".to_string())),
RecordField::new_record_field("pinCode".to_string(),Value::String("1234567890".to_string()) , Some("My Pin Code Field Lbl".to_string())),
RecordField::new_record_field("addressRef".to_string(),Value::String("some_UID".to_string()) , Some("My Address Reference".to_string())),
RecordField::new_record_field("phone".to_string(),json!({"region": "US", "number": "510-444-3333"}) , Some("My Phone Number".to_string())),
RecordField::new_record_field("date".to_string(),Value::Number(Number::from(1641934793000i64)) , Some("My date".to_string())),
RecordField::new_record_field("date".to_string(),Value::String("September eleventh two thousand and eleven".to_string()) , Some("Bad day in history of humanity".to_string())),
RecordField::new_record_field("name".to_string(),json!({"first": "Lincoln", "last": "Adams"}) , Some("His Name".to_string())),
];
created_record.fields = Some(fields);
created_record.custom = Some(
vec![
RecordField::new_record_field("phone".to_string(),json!({"region": "US", "number": "510-222-5555", "ext": "99887", "type": "Mobile"}) , Some("My Custom Phone Lbl".to_string())),
]
);
let _ = secrets_manager.create_secret("Shared_folder_uid".to_string(), created_record)?;
Ok(())
}シークレットの削除
シークレットマネージャーを使用して、Keeperのボルトからレコードを削除することができます。
レコードを削除するには、シークレットマネージャーアプリケーションがそのレコードが属する共有フォルダにアクセスできること、および編集権限を持っていることが必要です。また、レコードを削除するには、シークレットマネージャーSDKにレコードのUIDを指定する必要があります。
// シークレットマネージャーを設定
val storage = LocalConfigStorage("ksm-config.json")
//initializeStorage(storage, "<One Time Access Token>")
val smOptions = SecretsManagerOptions(storage)
// レコードUIDで特定のシークレットを削除
deleteSecret(smOptions, List.of("EG6KdJaaLG7esRZbMnfbFA"));// シークレットマネージャーを設定
const smOptions = { storage: localConfigStorage("ksm-config.json")
// レコードUIDで特定のシークレットを削除
await deleteSecret(smOptions, ["EG6KdJaaLG7esRZbMnfbFA"]);from keeper_secrets_manager_core import SecretsManager
from keeper_secrets_manager_core.storage import FileKeyValueStorage
# シークレットマネージャーを設定
secrets_manager = SecretsManager(
token='<One Time Access Token>',
config=FileKeyValueStorage('ksm-config.json')
)
# レコードUIDで特定のシークレットを削除
secret = secrets_manager.delete_secret('EG6KdJaaLG7esRZbMnfbFA')using SecretsManager;
// シークレットマネージャーを設定
var storage = new LocalConfigStorage("ksm-config.json");
//SecretsManagerClient.InitializeStorage(storage, "<One Time Access Token>");
var smOptions = new SecretsManagerOptions(storage);
// レコードUIDで特定のシークレットを削除
await SecretsManagerClient.DeleteSecret(smOptions, new string[] {"EG6KdJaaLG7esRZbMnfbFA"});import ksm "github.com/keeper-security/secrets-manager-go/core"
func main() {
// シークレットマネージャーを設定
options := &ksm.ClientOptions{
// Token: "<One Time Access Token>",
Config: ksm.NewFileKeyValueStorage("ksm-config.json")}
secretsManager := ksm.NewSecretsManager(options)
// レコードUIDで特定のシークレットを削除
secrets, err = secretsManager.DeleteSecrets([]string{"EG6KdJaaLG7esRZbMnfbFA"})
}use keeper_secrets_manager_core::{core::{ClientOptions, SecretsManager}, custom_error::KSMRError, storage::FileKeyValueStorage};
fn main()-> Result<(), KSMRError>{
let token = "<Your One time token>".to_string();
let file_name = FileKeyValueStorage::new_config_storage("test.json".to_string())?;
let client_options = ClientOptions::new_client_options(token, file_name);
println!("Delete Secrets --------------------------------------------------------------");
let mut secrets_manager_3 = SecretsManager::new(client_options)?;
let uids = vec!["<secret uid>".to_string()];
let secrets_records_3 = secrets_manager_3.delete_secret(uids.clone())?;
Ok(())
}スクリプトの実装
KeeperシークレットマネージャーCLIは、任意のシステムコマンドを実行するラッパー関数を提供しており、その中で使用される環境変数をKeeperのボルトから取得した値に置き換えることができます。
ボルトおよび管理者用SDK
ボルトおよび管理レベルでの高度な機能については、各種開発ツールへのリンクを含むボルトSDKのページをご覧ください。
最終更新

