Como posso manter um arquivo na memória durante a edição?

Question

A versão curta: echo "teste" | vim - | grep "bom"

Isso não funciona como vim não vai saída para um pipe. Ele diz: "Vim: Aviso: A saída não é um terminal". Qualquer maneira de fazer isso? suporte multi-editor seria muito bom.

Eu tentei pipes nomeados, mas vim não vai abri-los.

versão

Long: echo $ passw | gpg q -d --passphrase-fd 0 $ filename | vim - | "Criptografar alguma forma gpg-lo usando $ passw e armazená-lo de volta em $ filename".

Eu estou tentando editar um arquivo criptografado gpg mas gostaria de não ter o arquivo descriptografado no disco a qualquer momento.

O script completo está aqui: https://github.com/ptarjan/viencrypt

Answer 1

Você poderia apenas ter vim criptografá-lo para você.

Antes de salvar o arquivo no vim, filtrar o conteúdo através de seu encrypter gpg:

    :{range}![!]{filter} [!][arg]               *:range!*
          Filter {range} lines through the external program
          {filter}.  Vim replaces the optional bangs with the
          latest given command and appends the optional [arg].
          Vim saves the output of the filter command in a
          temporary file and then reads the file into the
          buffer.  Vim uses the 'shellredir' option to redirect
          the filter output to the temporary file.
          However, if the 'shelltemp' option is off then pipes
          are used when possible (on Unix).
          When the 'R' flag is included in 'cpoptions' marks in
          the filtered lines are deleted, unless the
          |:keepmarks| command is used.  Example: >
            :keepmarks '<,'>!sort
    <            
          When the number of lines after filtering is less than
          before, marks in the missing lines are deleted anyway.
        w 

Então, se você quiser filtrá-la através gpg (estou adivinhando as bandeiras aqui):

:%!gpg -q -d -p $password
:w $filename

Você precisa exportar as variáveis ??$password e meio ambiente $filename assim vim tem acesso a eles, se você quiser usá-los dentro vim.

Answer 2

Tenha em mente que, por padrão Vim irá criar um arquivo de swap em disco. Comece vim com o seguinte comando para evitá-lo:

vim "+set noswapfile"

Answer 3

Você poderia montar um sistema de arquivos tmpfs (que armazena dados na memória) em algum lugar e fazer o seu trabalho lá.

EDIT (!): Desculpe, fazer com que ramfs. A diferença é tmpfs pode ser paginada para o espaço de troca, o que você não quer. Alternativamente, você pode desligar todos os dispositivos de troca (com swapoff) e usar tmpfs.

Answer 4

Isso está correto: Vim não será emitido a um tubo. O Vim não tomar a sua entrada e saída para um tubo, em vez disso, envia-lo em uma janela de edição onde você pode editá-lo. Você não pode continuar a seqüência de tubo depois vim. Portanto, tente:

echo $ passw | gpg q -d --passphrase-fd 0 $ filename | vim -

Ou não usar vim em tudo.

Se você quiser editar o arquivo antes de passar de volta para gpg você vai ter que fazer isso em um processo de duas etapas.

Answer 5

Você pode usar o comando %p para imprimir o arquivo que está sendo editado para a saída padrão.

Neste exemplo, o Vim lê sua entrada padrão e envia para a saída padrão:

$ (echo one; echo two; echo three; echo four) | \
  vim - -nes -u NONE  -c ':%p' -c ':q!' | \
  tail -n +2 | \
  grep t
two
three

Notas:

• vim -: ler da entrada padrão
• -n: não criar swapfile, only memory uso
• -e: iniciar no modo ex
• -s: modo silencioso ou lote
• -u NONE:. Não lê a .vimrc (Se você quiser que o seu .vimrc para ser lido, pule esta opção, mas diferentes pessoas têm diferentes .vimrc-s, por isso, se você fizer -u NONE não escrita, seu código pode não funcionar para um diferente pessoa ou mesmo para você, se você mudar de .vimrc.)
• -c <something>: executar algo como um comando
• -c ':%p': imprimir o conteúdo do buffer para a saída padrão
• -c 'q!': sair sem salvar
• tail -n +2: atire a primeira linha da saída Vim embora (que é a linha 'Vim: Reading from stdin...')

No exemplo a seguir, o Vim faz realmente algo útil:. Ele exclui a primeira coluna da entrada padrão

$ (echo one; echo two; echo three; echo four) | \
  vim - -nes -u NONE  -c ':exec "normal G\<c-v>ggx"' -c ':%p' -c ':q!' | \
  tail -n +2
ne
wo
hree
our

Notas:

• :exec: execute o seguinte comando (comando de linha de comando, não é normal comando mode)
• normal: um comando de linha de comando que executa o dado modo normal comandos
• G: ir para a última linha do arquivo
• \<c-v>: Seleção bloco inicial
• gg: Vá para a primeira linha
• x: excluir os caracteres selecionados

EDIT:

Posso dizer questão vim a ":% p" logo depois que eu ": wq"? Da sessão interativa

Você pode dizer coisas Vim como "executar o comando X antes de sair", utilizando, por exemplo a VimLeave autocommand (veja :help autocommand, :help VimLeave):

$ (echo "line 1"; echo "line 2") | \
  vim - -nes -u NONE -c ':autocmd VimLeave * :%p'
Vim: Reading from stdin...
:q!        # you type :q!
line 1
line 2

O problema é com o comando: "% p". Se você usa o argumento "-e", você não vai obter o editor visual. Se você não usar "-e", o Vim não vai imprimir o resultado da ":% P". Para a saída padrão, mas ao terminal

Eu vou fazer uma sugestão diferente em outro post.

Answer 6

Uma solução para o problema original (tanto quanto eu vê-lo):

secret.txt contém o texto criptografado.

./encode.sh é o script codificador simétrica.

O comando a seguir irá ler o texto de secret.txt, decodificar, torná-lo editável no Vim, codificar, e escrevê-lo de volta para secret.txt:

$ cp secret.txt | \
  ./encode.sh | \
  vim - -n -u NONE \
      -c ':autocmd VimLeave * :exec "%!./encode.sh" | write! tmp'; \
  mv tmp secret.txt

Notas:

• :autocmd VimLeave * <command>: realizar <command> antes de sair Vim em qualquer arquivo
• :exec "%!./encode.sh" | write! secret.txt: executar ./encode.sh em geral conteúdo do buffer como um filtro, em seguida, escrever o buffer em secret.txt
• "Como um filtro" significa que o conteúdo da memória intermédia serão alimentados para dentro ./encode.sh. O conteúdo da memória intermédia serão substituídos com a norma saída do ./encode.sh depois de terminar a sua execução.

Mas eu tenho que dizer, esta solução é feio. Eu recomendaria o mesmo que rampion :. ter um olhar para os autocomandos mencionados (:help autocommand) e tentar fazer todo o processo de edição dentro Vim

Finalmente uma nota lateral: O Vim tem o seu próprio comando de criptografia que faz exatamente o que você descreveu em seu projeto página web :" ele simplesmente decifra o arquivo em um arquivo legível apenas por você, você editá-lo no seu editor favorito, e então rencrypts e economiza a parte de trás do arquivo de onde ele veio. "

O Vim ajuda (:help :X) diz sobre o algoritmo:

• O algoritmo usado é quebrável. Uma chave 4 personagem em cerca de uma hora, a 6 tecla do caractere em um dia (em um PC Pentium 133). Isto requer que você sabe algum texto que deve aparecer no arquivo. Um especialista pode quebrá-lo para qualquer tecla. Quando o texto foi decifrada, isso também significa que a chave pode ser revelado, e outros arquivos criptografados com a mesma chave pode ser decifrado.
• Pkzip usa a mesma criptografia e US Govt não tem qualquer objecção à sua exportação. arquivo público do Pkzip APPNOTE.TXT descreve este algoritmo em detalhes.

Answer 7

Outra opção é usar a gnupg plugin para Vim em vez de reinventando a roda. :) Claro, eu sou um pouco tendenciosa desde que eu sou o mantenedor atual do plugin.

Answer 8

Você não pode esconder nada de usuário root, mesmo na memória (eles têm acesso a / dev / mem). Isso é um fato que não pode ser evitado.

Então eu arquivos temporários é só usar em seu diretório home, que devem ser protegidos contra todos, exceto raiz. Em uma linha, digite:

echo "testing" >~/proc$$ ; vim ~/proc$$ ;
    grep "good" ~/proc$$ ; rm -f ~/proc$$

Se você quer segurança real, mover o arquivo para uma caixa onde você é o único usuário root e fazê-lo lá. Em seguida, passar a parte de trás arquivo criptografado.