From 29d23042af2272908dd281dadcdab4e1d88cf0d3 Mon Sep 17 00:00:00 2001 From: Fierelier Date: Tue, 20 Aug 2024 13:58:55 +0200 Subject: [PATCH] Add prpw-tui --- lib/base64.lua | 201 ++++++++++++++++++++++++++++++++++++++++ prpw-tui | 247 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 448 insertions(+) create mode 100644 lib/base64.lua create mode 100755 prpw-tui diff --git a/lib/base64.lua b/lib/base64.lua new file mode 100644 index 0000000..32de332 --- /dev/null +++ b/lib/base64.lua @@ -0,0 +1,201 @@ +--[[ + + base64 -- v1.5.3 public domain Lua base64 encoder/decoder + no warranty implied; use at your own risk + + Needs bit32.extract function. If not present it's implemented using BitOp + or Lua 5.3 native bit operators. For Lua 5.1 fallbacks to pure Lua + implementation inspired by Rici Lake's post: + http://ricilake.blogspot.co.uk/2007/10/iterating-bits-in-lua.html + + author: Ilya Kolbin (iskolbin@gmail.com) + url: github.com/iskolbin/lbase64 + + COMPATIBILITY + + Lua 5.1+, LuaJIT + + LICENSE + + See end of file for license information. + +--]] + + +local base64 = {} + +local extract = _G.bit32 and _G.bit32.extract -- Lua 5.2/Lua 5.3 in compatibility mode +if not extract then + if _G.bit then -- LuaJIT + local shl, shr, band = _G.bit.lshift, _G.bit.rshift, _G.bit.band + extract = function( v, from, width ) + return band( shr( v, from ), shl( 1, width ) - 1 ) + end + elseif _G._VERSION == "Lua 5.1" then + extract = function( v, from, width ) + local w = 0 + local flag = 2^from + for i = 0, width-1 do + local flag2 = flag + flag + if v % flag2 >= flag then + w = w + 2^i + end + flag = flag2 + end + return w + end + else -- Lua 5.3+ + extract = load[[return function( v, from, width ) + return ( v >> from ) & ((1 << width) - 1) + end]]() + end +end + + +function base64.makeencoder( s62, s63, spad ) + local encoder = {} + for b64code, char in pairs{[0]='A','B','C','D','E','F','G','H','I','J', + 'K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y', + 'Z','a','b','c','d','e','f','g','h','i','j','k','l','m','n', + 'o','p','q','r','s','t','u','v','w','x','y','z','0','1','2', + '3','4','5','6','7','8','9',s62 or '+',s63 or'/',spad or'='} do + encoder[b64code] = char:byte() + end + return encoder +end + +function base64.makedecoder( s62, s63, spad ) + local decoder = {} + for b64code, charcode in pairs( base64.makeencoder( s62, s63, spad )) do + decoder[charcode] = b64code + end + return decoder +end + +local DEFAULT_ENCODER = base64.makeencoder() +local DEFAULT_DECODER = base64.makedecoder() + +local char, concat = string.char, table.concat + +function base64.encode( str, encoder, usecaching ) + encoder = encoder or DEFAULT_ENCODER + local t, k, n = {}, 1, #str + local lastn = n % 3 + local cache = {} + for i = 1, n-lastn, 3 do + local a, b, c = str:byte( i, i+2 ) + local v = a*0x10000 + b*0x100 + c + local s + if usecaching then + s = cache[v] + if not s then + s = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[extract(v,6,6)], encoder[extract(v,0,6)]) + cache[v] = s + end + else + s = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[extract(v,6,6)], encoder[extract(v,0,6)]) + end + t[k] = s + k = k + 1 + end + if lastn == 2 then + local a, b = str:byte( n-1, n ) + local v = a*0x10000 + b*0x100 + t[k] = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[extract(v,6,6)], encoder[64]) + elseif lastn == 1 then + local v = str:byte( n )*0x10000 + t[k] = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[64], encoder[64]) + end + return concat( t ) +end + +function base64.decode( b64, decoder, usecaching ) + decoder = decoder or DEFAULT_DECODER + local pattern = '[^%w%+%/%=]' + if decoder then + local s62, s63 + for charcode, b64code in pairs( decoder ) do + if b64code == 62 then s62 = charcode + elseif b64code == 63 then s63 = charcode + end + end + pattern = ('[^%%w%%%s%%%s%%=]'):format( char(s62), char(s63) ) + end + b64 = b64:gsub( pattern, '' ) + local cache = usecaching and {} + local t, k = {}, 1 + local n = #b64 + local padding = b64:sub(-2) == '==' and 2 or b64:sub(-1) == '=' and 1 or 0 + for i = 1, padding > 0 and n-4 or n, 4 do + local a, b, c, d = b64:byte( i, i+3 ) + local s + if usecaching then + local v0 = a*0x1000000 + b*0x10000 + c*0x100 + d + s = cache[v0] + if not s then + local v = decoder[a]*0x40000 + decoder[b]*0x1000 + decoder[c]*0x40 + decoder[d] + s = char( extract(v,16,8), extract(v,8,8), extract(v,0,8)) + cache[v0] = s + end + else + local v = decoder[a]*0x40000 + decoder[b]*0x1000 + decoder[c]*0x40 + decoder[d] + s = char( extract(v,16,8), extract(v,8,8), extract(v,0,8)) + end + t[k] = s + k = k + 1 + end + if padding == 1 then + local a, b, c = b64:byte( n-3, n-1 ) + local v = decoder[a]*0x40000 + decoder[b]*0x1000 + decoder[c]*0x40 + t[k] = char( extract(v,16,8), extract(v,8,8)) + elseif padding == 2 then + local a, b = b64:byte( n-3, n-2 ) + local v = decoder[a]*0x40000 + decoder[b]*0x1000 + t[k] = char( extract(v,16,8)) + end + return concat( t ) +end + +return base64 + +--[[ +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2018 Ilya Kolbin +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +------------------------------------------------------------------------------ +--]] diff --git a/prpw-tui b/prpw-tui new file mode 100755 index 0000000..f39c4bb --- /dev/null +++ b/prpw-tui @@ -0,0 +1,247 @@ +#!/usr/bin/env lua +basepath = (debug.getinfo(1, "S").source:sub(2):match("(.*[/\\])") or "./"):sub(1,-2) +local entryBackups = {} + +local function makeEntryBackup(id) + if entryBackups[id] ~= nil then return end + env.run({"entry_backup",id}) + entryBackups[id] = true +end + +local function eprint(text) + io.stderr:write(text .. "\n") +end + +local function input(text) + if text == nil then text = "" end + io.stderr:write(text) + return io.read() +end + +local function yn(question) + io.stderr:write(question .. " - y/n: ") + local inp = false + while true do + inp = string.lower(input()) + if ( + inp == "y" or + inp == "n" + ) then break end + end + return (inp == "y") +end + +local function menu(choices) + for i,v in ipairs(choices) do + eprint(tostring(i).. ": " ..tostring(v)) + end + local choice = false + while true do + choice = tonumber(input("Choice: ")) + if not ( + choice == nil or + choice < 1 or + choice > #choices or + math.floor(choice) ~= choice + ) then + break + end + end + return choice +end + +local function emenu(title,choices,functions,lastSelection) + if lastSelection == nil then lastSelection = "<- BACK" end + table.insert(choices,lastSelection) + while true do + eprint(title) + local i = menu(choices) + if i == #choices then + return + end + eprint("") + functions[i]() + eprint("") + end +end + +local function printPassword(entry) + print(env.run({"field_get",entry.attrs.id,"password"})) +end + +local function fieldPrint(entry,field) + print(env.run({"field_get",entry.attrs.id,field.attrs.name})) +end + +local function fieldPrintType(entry,field) + print(env.run({"field_get_type",entry.attrs.id,field.attrs.name})) +end + +local function fieldSetText(entry,field) + local text = input("Text: ") + makeEntryBackup(entry.attrs.id) + env.run({"field_set",entry.attrs.id,field.attrs.name,text}) + env.run({"save"}) +end + +local function fieldSetType(entry,field) + local tp = input("Type: ") + makeEntryBackup(entry.attrs.id) + env.run({"field_set_type",entry.attrs.id,field.attrs.name,tp}) + env.run({"save"}) +end + +local function fieldRemove(entry,field) + if not yn("Do you want to remove the field '" .. "'?") then return end + makeEntryBackup(entry.attrs.id) + env.run({"field_remove",entry.attrs.id,field.attrs.name}) + env.run({"save"}) +end + +local function fieldImportFile(entry,field) + local fpath = input("File path: ") + local fh = io.open(fpath,"r") + if fh == nil then + eprint("Error opening file, make sure to remove any \" or '.") + return + end + + local bytes = fh:read("*a") + fh:close() + local base64 = require("base64") + bytes = base64.encode(bytes) + makeEntryBackup(entry.attrs.id) + env.run({"field_set",entry.attrs.id,field.attrs.name,bytes}) + bytes = nil + collectgarbage("collect") + env.run({"save"}) +end + +local function fieldExportFile(entry,field) + local fpath = input("File path: ") + local fh = io.open(fpath,"r") + if fh ~= nil then + fh:close() + eprint("Error: file already exists.") + return + end + + fh = io.open(fpath,"w") + if fh == nil then + eprint("Error opening file, make sure to remove any \" or '.") + return + end + + local bytes = env.run({"field_get",entry.attrs.id,field.attrs.name}) + local base64 = require("base64") + bytes = base64.decode(bytes) + fh:write(bytes) + fh:close() + bytes = nil + collectgarbage("collect") +end + +local function fieldActions(entry,field) + emenu( + "Field '" ..field.attrs.name.. "':", + { + "Print value + exit", + "Print value", + "Print type", + "Set value", + "Set type", + "Import file", + "Export file", + "Rename", + "Remove" + }, + { + function() fieldPrint(entry,field); os.exit(0) end, + function() fieldPrint(entry,field) end, + function() fieldPrintType(entry,field) end, + function() fieldSetText(entry,field) end, + function() fieldSetType(entry,field) end, + function() fieldImportFile(entry,field) end, + function() fieldExportFile(entry,field) end, + function() fieldRename(entry,field) end, --todo (needs prpw impl) + function() fieldRemove(entry,field) end + } + ) +end + +local function fieldsActions(entry) + local fields = env.run({"field_list",entry.attrs.id}) + local funcs = {} + for i,field in pairs(fields) do + fields[i] = field.attrs.name; + table.insert(funcs,function() fieldActions(entry,field) end) + end + emenu("Fields:",fields,funcs) +end + +local function fieldAdd(entry) + local fieldName = input("Field name: ") + makeEntryBackup(entry.attrs.id) + env.run({"field_set",entry.attrs.id,fieldName,""}) + env.run({"save"}) +end + +local function manageEntry(entry) + emenu( + "Entry - " ..entry.attrs.name.. ":", + { + "Print password + exit", + "Field add", + "Fields", + "Entry rename", + "Entry remove" + }, + { + function() printPassword(entry); os.exit(0) end, + function() fieldAdd(entry) end, + function() fieldsActions(entry) end, + function() entryRename(entry) end, --todo (needs prpw impl) + function() entryRemove(entry) end --todo + } + ) +end + +local function searchByName() + local entries = {} + local entriesMenu = {} + local name = string.lower(input("Name: ")) + + for i,entry in pairs(env.xmlFindTags(env.db,"entries")[1].children) do + if string.find(string.lower(entry.attrs.name),name) ~= nil then + table.insert(entries,function() manageEntry(entry) end) + table.insert(entriesMenu,entry.attrs.name) + end + end + emenu("Found entries:",entriesMenu,entries) +end + +local function main(arg) + package.path = basepath .. "/lib/?.lua;" .. basepath .. "/lib/?/main.lua;" .. package.path + require("prpw") + env.cli = false + env.run({"open",arg[1]}) + + emenu( + "Search entry by ...", + { + "Name", + "All non-secret field contents", + "Field content", + "List all" + }, + { + searchByName, + searchByFields, -- todo + searchByField, -- todo + listAll -- todo + }, + "<- EXIT" + ) +end + +main(arg)