nishiki/mpw
1
0
Fork 0
Code Issues Releases Activity

Compare commits

..

No commits in common. "master" and "3.0.0" have entirely different histories.
master ... 3.0.0

53 changed files with 2222 additions and 3731 deletions

32
.docker-test
View file

@ -1,32 +0,0 @@
#!/bin/bash
ruby_version=${1:-2.4.2}
if ! rvm use ruby-${ruby_version} &>/dev/null ; then
echo "The ruby version '${ruby_version}' doesn't exist!"
echo "Available versions are:"
rvm list rubies strings | cut -d '-' -f2
exit 2
fi
echo '# ---------------------------------'
echo "# Use ruby version: ${ruby_version}"
echo '# ---------------------------------'
cp -r /mpw ~/mpw
cd ~/mpw
gem install bundler --no-ri --no-rdoc
bundle install
gem build mpw.gemspec
gem install mpw-$(cat VERSION).gem
cp -a /dev/urandom /dev/random
rubocop
ruby ./test/init.rb
ruby ./test/test_config.rb
ruby ./test/test_item.rb
ruby ./test/test_mpw.rb
ruby ./test/test_translate.rb
ruby ./test/init.rb
ruby ./test/test_cli.rb
ruby ./test/test_import.rb

3
.gitignore vendored
View file

@ -1,4 +1 @@
Gemfile.lock Gemfile.lock
*.gem
.yardoc
doc

38
.rubocop.yml
View file

@ -1,38 +0,0 @@
AllCops:
Exclude:
- db/**/*
- config/**/*
- Vagrantfile
TargetRubyVersion: 2.3
Naming/AccessorMethodName:
Enabled: false
Lint/RescueWithoutErrorClass:
Enabled: false
Metrics/LineLength:
Max: 120
Metrics/CyclomaticComplexity:
Enabled: false
Metrics/PerceivedComplexity:
Enabled: false
Metrics/MethodLength:
Enabled: false
Metrics/BlockLength:
Enabled: false
Metrics/ClassLength:
Enabled: false
Metrics/AbcSize:
Enabled: false
Style/NumericLiteralPrefix:
Enabled: false
Style/FrozenStringLiteralComment:
Enabled: false
Style/CommandLiteral:
Enabled: true
EnforcedStyle: percent_x
Style/Documentation:
Enabled: false

23
.travis.yml
View file

@ -1,23 +0,0 @@
language: ruby
dist: precise
rvm:
- 2.4.2
- 2.3.5
- 2.2.8
- 2.1.10
install:
- sudo cp -a /dev/urandom /dev/random
- sudo apt-get purge -y gnupg-agent gnupg2
- bundle install
- gem build mpw.gemspec
- gem install mpw-$(cat VERSION).gem
script:
- rubocop
- ruby ./test/init.rb
- ruby ./test/test_config.rb
- ruby ./test/test_item.rb
- ruby ./test/test_mpw.rb
- ruby ./test/test_translate.rb
- ruby ./test/init.rb
- ruby ./test/test_cli.rb
- ruby ./test/test_import.rb

13
CHANGELOG Normal file
View file

@ -0,0 +1,13 @@
= CHANGELOG =
== v2.0.0 ==
* change format csv to yaml
* easy install with gem
* add sync with ftp and ssh
* many improvement
== v1.1.0 ==
* Add sync with MPW Server
* Add MPW Server
* Fix minors bugs

98
CHANGELOG.md
View file

@ -1,98 +0,0 @@
# CHANGELOG
## v4.2.2 (2017-08-15)
* minor improvements in the interface
## v4.2.1 (2017-07-30)
* fix bug in otp generator
## v4.2.0 (2017-06-06)
* feat: improve the interface
* feat: add copy url
* feat: add unit tests for cli
* feat: comment the code with yarn syntax
* fix several bugs
* fix translations
## v4.1.1 (2017-05-03)
* fix bug in init
## v4.1.0 (2017-04-22)
* feat: add options to update or add an item in command line
* feat: print config
* feat: add a specific path for a wallet
* feat: add rubocop to fix syntax
* fix: pinentry mode with gpg >= 2.1
* remove SSH and FTP synchronization
## v4.0.0 (2017-03-09)
* feature: set default wallet
* add option for generate a random password when you update an item
* fix encryption when you share an existing wallet
* several bugs fix
## v4.0.0-beta1 (2017-02-16)
* add manage share key with new interface
## v4.0.0-beta (2016-11-11)
* new interface with a table
* new command line interface
* use text editor for add or update an item
* fix generate gpg key with RSA
* several bugs fix
* add unit tests
## v3.2.1 (2016-08-06)
* fix bug when add a new item
## v3.2.0 (2016-08-03)
* add support OTP
* fix bug in synchronize
* improve interface
## v3.1.0 (2016-07-09)
* add clipboard
* can change gpg version
* minor change in interface
* several bugs fix
## v3.0.0 (2016-07-05)
* new storage format
* new share system
* remove MPW server
## v2.0.3 (2015-09-27)
* add no-sync option
## v2.0.1 (2015-06-23)
* fix mpw-ssh
## v2.0.0 (2015-06-22)
* change format csv to yaml
* easy install with gem
* add sync with ftp and ssh
* many improvement
## v1.1.0 (2014-01-28)
* Add sync with MPW Server
* Add MPW Server
* Fix minors bugs
## v1.0.0 (2014-01-15)
* first release

16
Dockerfile
View file

@ -1,16 +0,0 @@
FROM debian:stretch
MAINTAINER Adrien Waksberg "mpw@yae.im"
RUN apt update
RUN apt dist-upgrade -y
RUN apt install -y procps gnupg1 curl git
RUN ln -snvf /usr/bin/gpg1 /usr/bin/gpg
RUN gpg --keyserver hkp://keys.gnupg.net --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDB
RUN curl -sSL https://get.rvm.io | bash -s stable
RUN echo 'source "/usr/local/rvm/scripts/rvm"' >> /etc/bash.bashrc
RUN /bin/bash -l -c "rvm install 2.4.2"
RUN /bin/bash -l -c "rvm install 2.3.5"
RUN /bin/bash -l -c "rvm install 2.2.8"
RUN /bin/bash -l -c "rvm install 2.1.10"

20
Gemfile
View file

@ -1,14 +1,8 @@
source 'https://rubygems.org' source 'https://rubygems.org'
gem 'clipboard', '~> 1.1', '>= 1.1.1' gem 'highline'
gem 'colorize', '~> 0.8', '>= 0.8.1' gem 'i18n'
gem 'gpgme', '~> 2.0', '>= 2.0.14' gem 'locale'
gem 'highline', '~> 1.7', '>= 1.7.8' gem 'gpgme'
gem 'i18n', '~> 0.9', '>= 0.9.1' gem 'colorize'
gem 'locale', '~> 2.1', '>= 2.1.2' gem 'net-ssh'
gem 'rotp', '~> 3.3', '>= 3.3.0' gem 'net-scp'
group :development do
gem 'rubocop', '0.50.0'
gem 'test-unit'
gem 'yard'
end

476
LICENSE
View file

@ -1,201 +1,339 @@
Apache License GNU GENERAL PUBLIC LICENSE
Version 2.0, January 2004 Version 2, June 1991
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
1. Definitions. Preamble
"License" shall mean the terms and conditions for use, reproduction, The licenses for most software are designed to take away your
and distribution as defined by Sections 1 through 9 of this document. freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Lesser General Public License instead.) You can apply it to
your programs, too.
"Licensor" shall mean the copyright owner or entity authorized by When we speak of free software, we are referring to freedom, not
the copyright owner that is granting the License. price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
"Legal Entity" shall mean the union of the acting entity and all To protect your rights, we need to make restrictions that forbid
other entities that control, are controlled by, or are under common anyone to deny you these rights or to ask you to surrender the rights.
control with that entity. For the purposes of this definition, These restrictions translate to certain responsibilities for you if you
"control" means (i) the power, direct or indirect, to cause the distribute copies of the software, or if you modify it.
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity For example, if you distribute copies of such a program, whether
exercising permissions granted by this License. gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
"Source" form shall mean the preferred form for making modifications, We protect your rights with two steps: (1) copyright the software, and
including but not limited to software source code, documentation (2) offer you this license which gives you legal permission to copy,
source, and configuration files. distribute and/or modify the software.
"Object" form shall mean any form resulting from mechanical Also, for each author's protection and ours, we want to make certain
transformation or translation of a Source form, including but that everyone understands that there is no warranty for this free
not limited to compiled object code, generated documentation, software. If the software is modified by someone else and passed on, we
and conversions to other media types. want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
"Work" shall mean the work of authorship, whether in Source or Finally, any free program is threatened constantly by software
Object form, made available under the License, as indicated by a patents. We wish to avoid the danger that redistributors of a free
copyright notice that is included in or attached to the work program will individually obtain patent licenses, in effect making the
(an example is provided in the Appendix below). program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
"Derivative Works" shall mean any work, whether in Source or Object The precise terms and conditions for copying, distribution and
form, that is based on (or derived from) the Work and for which the modification follow.
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including GNU GENERAL PUBLIC LICENSE
the original version of the Work and any modifications or additions TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity 0. This License applies to any program or other work which contains
on behalf of whom a Contribution has been received by Licensor and a notice placed by the copyright holder saying it may be distributed
subsequently incorporated within the Work. under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
2. Grant of Copyright License. Subject to the terms and conditions of Activities other than copying, distribution and modification are not
this License, each Contributor hereby grants to You a perpetual, covered by this License; they are outside its scope. The act of
worldwide, non-exclusive, no-charge, royalty-free, irrevocable running the Program is not restricted, and the output from the Program
copyright license to reproduce, prepare Derivative Works of, is covered only if its contents constitute a work based on the
publicly display, publicly perform, sublicense, and distribute the Program (independent of having been made by running the Program).
Work and such Derivative Works in Source or Object form. Whether that is true depends on what the Program does.
3. Grant of Patent License. Subject to the terms and conditions of 1. You may copy and distribute verbatim copies of the Program's
this License, each Contributor hereby grants to You a perpetual, source code as you receive it, in any medium, provided that you
worldwide, non-exclusive, no-charge, royalty-free, irrevocable conspicuously and appropriately publish on each copy an appropriate
(except as stated in this section) patent license to make, have made, copyright notice and disclaimer of warranty; keep intact all the
use, offer to sell, sell, import, and otherwise transfer the Work, notices that refer to this License and to the absence of any warranty;
where such license applies only to those patent claims licensable and give any other recipients of the Program a copy of this License
by such Contributor that are necessarily infringed by their along with the Program.
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the You may charge a fee for the physical act of transferring a copy, and
Work or Derivative Works thereof in any medium, with or without you may at your option offer warranty protection in exchange for a fee.
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or 2. You may modify your copy or copies of the Program or any portion
Derivative Works a copy of this License; and of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
(b) You must cause any modified files to carry prominent notices a) You must cause the modified files to carry prominent notices
stating that You changed the files; and stating that you changed the files and the date of any change.
(c) You must retain, in the Source form of any Derivative Works b) You must cause any work that you distribute or publish, that in
that You distribute, all copyright, patent, trademark, and whole or in part contains or is derived from the Program or any
attribution notices from the Source form of the Work, part thereof, to be licensed as a whole at no charge to all third
excluding those notices that do not pertain to any part of parties under the terms of this License.
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its c) If the modified program normally reads commands interactively
distribution, then any Derivative Works that You distribute must when run, you must cause it, when started running for such
include a readable copy of the attribution notices contained interactive use in the most ordinary way, to print or display an
within such NOTICE file, excluding those notices that do not announcement including an appropriate copyright notice and a
pertain to any part of the Derivative Works, in at least one notice that there is no warranty (or else, saying that you provide
of the following places: within a NOTICE text file distributed a warranty) and that users may redistribute the program under
as part of the Derivative Works; within the Source form or these conditions, and telling the user how to view a copy of this
documentation, if provided along with the Derivative Works; or, License. (Exception: if the Program itself is interactive but
within a display generated by the Derivative Works, if and does not normally print such an announcement, your work based on
wherever such third-party notices normally appear. The contents the Program is not required to print an announcement.)
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and These requirements apply to the modified work as a whole. If
may provide additional or different license terms and conditions identifiable sections of that work are not derived from the Program,
for use, reproduction, or distribution of Your modifications, or and can be reasonably considered independent and separate works in
for any such Derivative Works as a whole, provided Your use, themselves, then this License, and its terms, do not apply to those
reproduction, and distribution of the Work otherwise complies with sections when you distribute them as separate works. But when you
the conditions stated in this License. distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
5. Submission of Contributions. Unless You explicitly state otherwise, Thus, it is not the intent of this section to claim rights or contest
any Contribution intentionally submitted for inclusion in the Work your rights to work written entirely by you; rather, the intent is to
by You to the Licensor shall be under the terms and conditions of exercise the right to control the distribution of derivative or
this License, without any additional terms or conditions. collective works based on the Program.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade In addition, mere aggregation of another work not based on the Program
names, trademarks, service marks, or product names of the Licensor, with the Program (or with a work based on the Program) on a volume of
except as required for reasonable and customary use in describing the a storage or distribution medium does not bring the other work under
origin of the Work and reproducing the content of the NOTICE file. the scope of this License.
7. Disclaimer of Warranty. Unless required by applicable law or 3. You may copy and distribute the Program (or a work based on it,
agreed to in writing, Licensor provides the Work (and each under Section 2) in object code or executable form under the terms of
Contributor provides its Contributions) on an "AS IS" BASIS, Sections 1 and 2 above provided that you also do one of the following:
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory, a) Accompany it with the complete corresponding machine-readable
whether in tort (including negligence), contract, or otherwise, source code, which must be distributed under the terms of Sections
unless required by applicable law (such as deliberate and grossly 1 and 2 above on a medium customarily used for software interchange; or,
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing b) Accompany it with a written offer, valid for at least three
the Work or Derivative Works thereof, You may choose to offer, years, to give any third party, for a charge no more than your
and charge a fee for, acceptance of support, warranty, indemnity, cost of physically performing source distribution, a complete
or other liability obligations and/or rights consistent with this machine-readable copy of the corresponding source code, to be
License. However, in accepting such obligations, You may act only distributed under the terms of Sections 1 and 2 above on a medium
on Your own behalf and on Your sole responsibility, not on behalf customarily used for software interchange; or,
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
APPENDIX: How to apply the Apache License to your work. The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
To apply the Apache License to your work, attach the following If distribution of executable or object code is made by offering
boilerplate notice, with the fields enclosed by brackets "{}" access to copy from a designated place, then offering equivalent
replaced with your own identifying information. (Don't include access to copy the source code from the same place counts as
the brackets!) The text should be enclosed in the appropriate distribution of the source code, even though third parties are not
comment syntax for the file format. We also recommend that a compelled to copy the source along with the object code.
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2017 Adrien Waksberg 4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
Licensed under the Apache License, Version 2.0 (the "License"); 5. You are not required to accept this License, since you have not
you may not use this file except in compliance with the License. signed it. However, nothing else grants you permission to modify or
You may obtain a copy of the License at distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
http://www.apache.org/licenses/LICENSE-2.0 6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
Unless required by applicable law or agreed to in writing, software 7. If, as a consequence of a court judgment or allegation of patent
distributed under the License is distributed on an "AS IS" BASIS, infringement or for any other reason (not limited to patent issues),
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. conditions are imposed on you (whether by court order, agreement or
See the License for the specific language governing permissions and otherwise) that contradict the conditions of this License, they do not
limitations under the License. excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License.

230
README.md
View file

@ -1,195 +1,127 @@
# MPW: Manage your passwords! # Manage your passwords!
[![Version](https://img.shields.io/badge/latest_version-4.2.2-green.svg)](https://github.com/nishiki/manage-password/releases)
[![Build Status](https://travis-ci.org/nishiki/manage-password.svg?branch=master)](https://travis-ci.org/nishiki/manage-password)
[![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](https://github.com/nishiki/manage-password/blob/master/LICENSE)
mpw is a little software which stores your passwords in [GnuPG](http://www.gnupg.org/) encrypted files. MPW is a little software which stores your passwords in an GPG encrypted file.
MPW can synchronize your password with via SSH or FTP.
## Features # Installation
* generate random password This program work with ruby >= 2.0
* generate OTP code
* copy your login, password or otp in clipboard
* manage many wallets
* share a wallet with others GPG keys
## Install * install ruby and rubygems on your computer
* gem install mpw
On debian or ubuntu: # How to use
* Show help
``` ```
apt install ruby ruby-dev xclip mpw --help
gem install mpw
``` ```
## How to use * Setup a new config file
### First steps
Initialize your first wallet:
``` ```
mpw config --init user@host.com mpw --setup
mpw --setup --config /path/conf/file.cfg
``` ```
Add your first item: * Create and setup a new wallet
``` ```
mpw add --host assurance.com --port 443 --user user_2132 --protocol https --random mpw --setup-wallet --wallet new_wallet_name
mpw add --host fric.com --user 230403 --otp-code 23434113 --protocol https --comment 'I love my bank' --random mpw --setup-wallet --wallet new_wallet_name --config /path/conf/file.cfg
``` ```
And list your items: * Add a GPG key in wallet
``` ```
mpw list mpw --add --key root@localhost.local
``` mpw --add --key root@localhost.local --config /path/conf/file.cfg
or search an item with mpw --add --key root@localhost.local --wallet wallet_name
``` mpw --add --key root@localhost.local --config /path/conf/file.cfg --wallet wallet_name
mpw list --pattern love
mpw list --group bank
``` ```
Output: * Add a new GPG key in wallet
``` ```
Assurance mpw --add --key root@localhost.local --file /path/gpg/file.pub
========================================================================== mpw --add --key root@localhost.local --file /path/gpg/file.pub --config /path/conf/file.cfg
ID | Host | User | OTP | Comment mpw --add --key root@localhost.local --file /path/gpg/file.pub --wallet wallet_name
========================================================================== mpw --add --key root@localhost.local --file /path/gpg/file.pub --config /path/conf/file.cfg --wallet wallet_name
1 | https://assurance.com:443 | user_2132 | |
Bank
==========================================================================
ID | Host | User | OTP | Comment
==========================================================================
3 | https://fric.com | 230403 | X | I love my bank
``` ```
Copy a password, login or OTP code: * Delete a GPG key in wallet
``` ```
mpw copy -p assurance.com mpw --delete --key root@localhost.local
mpw --delete --key root@localhost.local --wallet wallet_name
mpw --delete --key root@localhost.local --wallet wallet_name --config /path/conf/file.cfg
``` ```
Update an item: * Add a new item in wallet
``` ```
mpw update -p assurance.com mpw --add
mpw --add --config /path/conf/file.cfg
mpw --add --wallet wallet_name
mpw --add --config /path/conf/file.cfg --wallet wallet_name
``` ```
Delete an item: * Update an item
``` ```
mpw delete -p assurance.com mpw --update --id uniq_id
mpw --update --id uniq_id --config /path/conf/file.cfg
mpw --update --id uniq_id --wallet wallet_name
mpw --update --id uniq_id --config /path/conf/file.cfg --wallet wallet_name
``` ```
### Manage wallets * Delete an item
List all available wallets:
``` ```
mpw wallet mpw --delete --id uniq_id
mpw --delete --id uniq_id --config /path/conf/file.cfg
mpw --delete --id uniq_id --wallet wallet_name
mpw --delete --id uniq_id --config /path/conf/file.cfg --wallet wallet_name
``` ```
List all GPG keys in wallet: * Show an item
``` ```
mpw wallet --list-keys [--wallet NAME] mpw --show 'string to search'
mpw --show 'string to search' --config /path/conf/file.cfg
mpw --show 'string to search' --wallet wallet_name
mpw --show 'string to search' --config /path/conf/file.cfg --wallet wallet_name
mpw --show 'string to search' --group group_name
mpw --show 'string to search' --group group_name --config /path/conf/file.cfg
mpw --show 'string to search' --group group_name --wallet wallet_name
mpw --show 'string to search' --group group_name --config /path/conf/file.cfg --wallet wallet_name
``` ```
Share with an other GPG key: * Export data in YAML file
``` ```
mpw wallet --add-gpg-key test42@localhost.com mpw --export --file /path/file/to/export.yml
or mpw --export --file /path/file/to/export.yml --config /path/conf/file.cfg
mpw wallet --add-gpg-key /path/to/file mpw --export --file /path/file/to/export.yml --wallet wallet_name
mpw --export --file /path/file/to/export.yml --config /path/conf/file.cfg --wallet wallet_name
``` ```
Remove a GPG key: * Import data from YAML file
``` ```
mpw wallet --delete-gpg-key test42@localhost.com mpw --import --file /path/file/to/export.yml
mpw --import --file /path/file/to/export.yml --config /path/conf/file.cfg
mpw --import --file /path/file/to/export.yml --wallet wallet_name
mpw --import --file /path/file/to/export.yml --config /path/conf/file.cfg --wallet wallet_name
``` ```
### Export and import data Format file to import:
You can export your data in yaml file with your passwords in clear text:
``` ```
mpw export --file export.yml
```
Import data from an yaml file:
```
mpw import --file import.yml
```
Example yaml file for mpw:
```
---
1: 1:
host: fric.com name: Website perso
user: 230403 group: Perso
group: Bank host: localhost.local
password: 5XdiTQOubRDw9B0aJoMlcEyL protocol: ftp
protocol: https user: test
port: password: letoortue
otp_key: 330223432 port: 21
comment: I love my bank comment: Mysuper website
2: 2:
host: assurance.com name: Linuxfr
user: user_2132 group: Pro
group: Assurance host: Linuxfr.org
password: DMyK6B3v4bWO52VzU7aTHIem
protocol: https protocol: https
port: 443 user: test
otp_key: password: coucou
comment: port:
``` comment:
### Config
Print the current config
```
mpw config
```
Output:
```
Configuration
==============================================
lang | fr
gpg_key | mpw@yae.im
default_wallet |
config_dir | /home/mpw/.config/mpw
pinmode | true
gpg_exe |
path_wallet_test | /tmp/test.mpw
password_numeric | true
password_alpha | true
password_special | false
password_length | 16
```
## Development
Don't run the tests on your local machine, you risk to lost your datas.
### Test on local machine with docker
* install [docker](https://docs.docker.com/engine/installation/)
* run the tests
```
docker run -v $(pwd):/mpw:ro -it nishiki/ruby:stretch /bin/bash -l /mpw/.docker-test
```
## License
```
* Author:: Adrien Waksberg <mpw@yae.im>
Copyright (c) 2013-2017 Adrien Waksberg
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
``` ```

2
VERSION
View file

@ -1 +1 @@
4.2.2 3.0.0

224
bin/mpw
View file

@ -1,30 +1,26 @@
#!/usr/bin/env ruby #!/usr/bin/ruby
# # MPW is a software to crypt and manage your passwords
# Copyright:: 2013, Adrien Waksberg # Copyright (C) 2016 Adrien Waksberg <mpw@yae.im>
# #
# Licensed to the Apache Software Foundation (ASF) under one # This program is free software; you can redistribute it and/or
# or more contributor license agreements. See the NOTICE file # modify it under the terms of the GNU General Public License
# distributed with this work for additional information # as published by the Free Software Foundation; either version 2
# regarding copyright ownership. The ASF licenses this file # of the License, or (at your option) any later version.
# to you under the Apache License, Version 2.0 (the #
# "License"); you may not use this file except in compliance # This program is distributed in the hope that it will be useful,
# with the License. You may obtain a copy of the License at # but WITHOUT ANY WARRANTY; without even the implied warranty of
# # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# http://www.apache.org/licenses/LICENSE-2.0 # GNU General Public License for more details.
# #
# Unless required by applicable law or agreed to in writing, # You should have received a copy of the GNU General Public License
# software distributed under the License is distributed on an # along with this program; if not, write to the Free Software
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
$LOAD_PATH << File.expand_path('../../lib', __FILE__)
require 'optparse'
require 'pathname'
require 'locale' require 'locale'
require 'set' require 'set'
require 'i18n' require 'i18n'
require 'colorize'
# --------------------------------------------------------- # # --------------------------------------------------------- #
# Set local # Set local
@ -33,11 +29,18 @@ require 'colorize'
lang = Locale::Tag.parse(ENV['LANG']).to_simple.to_s[0..1] lang = Locale::Tag.parse(ENV['LANG']).to_simple.to_s[0..1]
if defined?(I18n.enforce_available_locales) if defined?(I18n.enforce_available_locales)
I18n.enforce_available_locales = true I18n.enforce_available_locales = true
end end
APP_ROOT = File.dirname(Pathname.new(__FILE__).realpath)
# TODO
require "#{APP_ROOT}/../lib/mpw/mpw.rb"
require "#{APP_ROOT}/../lib/mpw/config.rb"
require "#{APP_ROOT}/../lib/mpw/ui/cli.rb"
I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks) I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
I18n.load_path = Dir["#{File.expand_path('../../i18n', __FILE__)}/*.yml"] I18n.load_path = Dir["#{APP_ROOT}/../i18n/*.yml"]
I18n.default_locale = :en I18n.default_locale = :en
I18n.locale = lang.to_sym I18n.locale = lang.to_sym
@ -45,28 +48,155 @@ I18n.locale = lang.to_sym
# Options # Options
# --------------------------------------------------------- # # --------------------------------------------------------- #
bin_dir = File.dirname(__FILE__) options = {}
command = "#{bin_dir}/mpw-#{ARGV[0]}" options[:force] = false
options[:sync] = true
options[:group] = nil
options[:config] = nil
options[:wallet] = nil
if Dir.glob("#{bin_dir}/mpw-*").include?(command.to_s) OptionParser.new do |opts|
begin opts.banner = "#{I18n.t('option.usage')}: mpw [options]"
Kernel.load(command)
rescue OptionParser::ParseError => e
puts "#{I18n.t('display.error')}: #{e}".red
end
else
puts "#{I18n.t('option.usage')}: mpw COMMAND [options]\n\n"
puts 'Commands:'
puts " add #{I18n.t('command.add')}"
puts " config #{I18n.t('command.config')}"
puts " copy #{I18n.t('command.copy')}"
puts " delete #{I18n.t('command.delete')}"
puts " export #{I18n.t('command.export')}"
puts " genpwd #{I18n.t('command.genpwd')}"
puts " import #{I18n.t('command.import')}"
puts " list #{I18n.t('command.list')}"
puts " update #{I18n.t('command.update')}"
puts " wallet #{I18n.t('command.wallet')}"
exit 3 opts.on('-a', '--add', I18n.t('option.add')) do
options[:add] = true
end
opts.on('-A', '--show-all', I18n.t('option.show_all')) do
options[:type] = nil
options[:show] = ''
end
opts.on('-c', '--config CONFIG', I18n.t('option.config')) do |config|
options[:config] = config
end
opts.on('-d', '--delete', I18n.t('option.remove')) do
options[:delete] = true
end
opts.on('-e', '--export', I18n.t('option.export')) do
options[:export] = true
end
opts.on('-f', '--file FILE', I18n.t('option.file')) do |file|
options[:file] = file
end
opts.on('-F', '--force', I18n.t('option.force')) do
options[:force] = true
end
opts.on('-g', '--group GROUP', I18n.t('option.group')) do |group|
options[:group] = group
end
opts.on('-G', '--generate-password [LENGTH]', I18n.t('option.generate_password')) do |length|
puts MPW::MPW::password(length)
exit 0
end
opts.on('-h', '--help', I18n.t('option.help')) do
puts opts
exit 0
end
opts.on('-i', '--id ID', I18n.t('option.id')) do |id|
options[:id] = id
end
opts.on('-I', '--import', I18n.t('option.import')) do
options[:import] = true
end
opts.on('-k', '--key KEY', I18n.t('option.key')) do |key|
options[:key] = key
end
opts.on('-N', '--no-sync', I18n.t('option.no_sync')) do
options[:sync] = false
end
opts.on('-s', '--show [SEARCH]', I18n.t('option.show')) do |search|
search.nil? ? (options[:show] = '') : (options[:show] = search)
end
opts.on('-S', '--setup', I18n.t('option.setup')) do
options[:setup] = true
end
opts.on('-u', '--update', I18n.t('option.update')) do
options[:update] = true
end
opts.on('-w', '--wallet WALLET', I18n.t('option.wallet')) do |wallet|
options[:wallet] = wallet
end
opts.on('-W', '--setup-wallet', I18n.t('option.setup_wallet')) do
options[:setup_wallet] = true
end
end.parse!
# --------------------------------------------------------- #
# Main
# --------------------------------------------------------- #
config = MPW::Config.new(options[:config])
cli = MPW::Cli.new(config, options[:sync])
# Setup a new config
if not config.is_valid? or not options[:setup].nil?
cli.setup(lang)
elsif not config.check_gpg_key?
cli.setup_gpg_key
end end
cli.get_wallet(options[:wallet])
cli.decrypt
# Display the item's informations
if not options[:show].nil?
opts = {search: options[:show],
group: options[:group],
}
cli.display(opts)
# Remove an item
elsif not options[:delete].nil? and not options[:id].nil?
cli.delete(options[:id], options[:force])
# Update an item
elsif not options[:update].nil? and not options[:id].nil?
cli.update(options[:id])
# Add a new item
elsif not options[:add].nil? and options[:key].nil?
cli.add
# Add a new public key in wallet
elsif not options[:add].nil? and not options[:key].nil?
cli.add_key(options[:key], options[:file])
# Delete a public key in wallet
elsif not options[:delete].nil? and not options[:key].nil?
cli.delete_key(options[:key])
# Export
elsif not options[:export].nil? and not options[:file].nil?
cli.export(options[:file])
# Add a new item
elsif not options[:import].nil? and not options[:file].nil?
cli.import(options[:file])
# Setup wallet config
elsif not options[:setup_wallet].nil?
cli.setup_wallet_config
end
cli = nil
exit 0

84
bin/mpw-add
View file

@ -1,84 +0,0 @@
#
# Copyright:: 2013, Adrien Waksberg
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
require 'optparse'
require 'mpw/config'
require 'mpw/cli'
# --------------------------------------------------------- #
# Options
# --------------------------------------------------------- #
values = {}
options = {}
options[:text_editor] = true
OptionParser.new do |opts|
opts.banner = "#{I18n.t('option.usage')}: mpw add [options]"
opts.on('-c', '--config PATH', I18n.t('option.config')) do |config|
options[:config] = config
end
opts.on('-C', '--comment COMMENT', I18n.t('option.comment')) do |comment|
values[:comment] = comment
end
opts.on('-G', '--group NAME', I18n.t('option.new_group')) do |group|
values[:group] = group
end
opts.on('-h', '--help', I18n.t('option.help')) do
puts opts
exit 0
end
opts.on('-o', '--otp-code CODE', I18n.t('option.otp_code')) do |otp|
values[:otp_key] = otp
end
opts.on('-r', '--random', I18n.t('option.random_password')) do
options[:password] = true
end
opts.on('-t', '--text-editor', I18n.t('option.text_editor')) do
options[:text_editor] = true
end
opts.on('-u', '--url URL', I18n.t('option.url')) do |url|
values[:url] = url
end
opts.on('-U', '--user USER', I18n.t('option.user')) do |user|
values[:user] = user
end
opts.on('-w', '--wallet NAME', I18n.t('option.wallet')) do |wallet|
options[:wallet] = wallet
end
end.parse!
config = MPW::Config.new(options[:config])
cli = MPW::Cli.new(config)
cli.load_config
cli.get_wallet(options[:wallet])
cli.decrypt
cli.add(options[:password], options[:text_editor], values)

121
bin/mpw-config
View file

@ -1,121 +0,0 @@
#
# Copyright:: 2013, Adrien Waksberg
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
require 'optparse'
require 'mpw/config'
require 'mpw/cli'
# --------------------------------------------------------- #
# Options
# --------------------------------------------------------- #
options = {}
values = {}
OptionParser.new do |opts|
opts.banner = "#{I18n.t('option.usage')}: mpw config [options]"
opts.on('-c', '--config PATH', I18n.t('option.config')) do |config|
options[:config] = config
end
opts.on('-d', '--default-wallet NAME', I18n.t('option.default_wallet')) do |default_wallet|
values[:default_wallet] = default_wallet
end
opts.on('-g', '--gpg-exe PATH', I18n.t('option.gpg_exe')) do |gpg_exe|
values[:gpg_exe] = gpg_exe
end
opts.on('-h', '--help', I18n.t('option.help')) do
puts opts
exit 0
end
opts.on('-i', '--init GPG_KEY', I18n.t('option.init')) do |gpg_key|
options[:init] = true
values[:gpg_key] = gpg_key
end
opts.on('-k', '--key GPG_KEY', I18n.t('option.gpg_key')) do |gpg_key|
values[:gpg_key] = gpg_key
end
opts.on('-L', '--lang LANG', I18n.t('option.lang')) do |lang|
values[:lang] = lang
end
opts.on('-P', '--enable-pinmode', I18n.t('option.pinmode')) do
values[:pinmode] = true
end
opts.on('-p', '--disable-pinmode', I18n.t('option.disable_pinmode')) do
values[:pinmode] = false
end
opts.on('-w', '--wallet-dir PATH', I18n.t('option.wallet_dir')) do |wallet_dir|
values[:wallet_dir] = wallet_dir
end
opts.on('-l', '--length NUMBER', I18n.t('option.length')) do |length|
values[:pwd_length] = length.to_i
end
opts.on('-n', '--numeric', I18n.t('option.numeric')) do
values[:pwd_numeric] = true
end
opts.on('-N', '--disable-numeric', I18n.t('option.disable_numeric')) do
values[:pwd_numeric] = false
end
opts.on('-s', '--special-chars', I18n.t('option.special_chars')) do
values[:pwd_special] = true
end
opts.on('-S', '--disable-special-chars', I18n.t('option.special_chars')) do
values[:pwd_special] = false
end
opts.on('-a', '--alpha', I18n.t('option.alpha')) do
values[:pwd_alpha] = true
end
opts.on('-A', '--disable-alpha', I18n.t('option.disable_alpha')) do
values[:pwd_alpha] = false
end
end.parse!
config = MPW::Config.new(options[:config])
cli = MPW::Cli.new(config)
if options.key?(:init)
cli.setup(values)
cli.load_config
cli.get_wallet
cli.setup_gpg_key(values[:gpg_key])
else
cli.load_config
if values.empty?
cli.list_config
else
cli.set_config(values)
end
end

68
bin/mpw-copy
View file

@ -1,68 +0,0 @@
#
# Copyright:: 2013, Adrien Waksberg
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
require 'optparse'
require 'mpw/config'
require 'mpw/cli'
# --------------------------------------------------------- #
# Options
# --------------------------------------------------------- #
options = {}
options[:clipboard] = true
values = {}
OptionParser.new do |opts|
opts.banner = "#{I18n.t('option.usage')}: mpw copy [options]"
opts.on('-c', '--config PATH', I18n.t('option.config')) do |config|
options[:config] = config
end
opts.on('-d', '--disable-clipboard', I18n.t('option.clipboard')) do
options[:clipboard] = false
end
opts.on('-g', '--group NAME', I18n.t('option.group')) do |group|
values[:group] = group
end
opts.on('-h', '--help', I18n.t('option.help')) do
puts opts
exit 0
end
opts.on('-p', '--pattern PATTERN', I18n.t('option.pattern')) do |pattern|
values[:pattern] = pattern
end
opts.on('-w', '--wallet NAME', I18n.t('option.wallet')) do |wallet|
options[:wallet] = wallet
end
end.parse!
config = MPW::Config.new(options[:config])
cli = MPW::Cli.new(config)
cli.load_config
cli.get_wallet(options[:wallet])
cli.decrypt
cli.copy(options[:clipboard], values)

63
bin/mpw-delete
View file

@ -1,63 +0,0 @@
#
# Copyright:: 2013, Adrien Waksberg
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
require 'optparse'
require 'mpw/config'
require 'mpw/cli'
# --------------------------------------------------------- #
# Options
# --------------------------------------------------------- #
options = {}
values = {}
OptionParser.new do |opts|
opts.banner = "#{I18n.t('option.usage')}: mpw delete [options]"
opts.on('-c', '--config PATH', I18n.t('option.config')) do |config|
options[:config] = config
end
opts.on('-g', '--group NAME', I18n.t('option.group')) do |group|
values[:group] = group
end
opts.on('-h', '--help', I18n.t('option.help')) do
puts opts
exit 0
end
opts.on('-p', '--pattern PATTERN', I18n.t('option.pattern')) do |pattern|
values[:pattern] = pattern
end
opts.on('-w', '--wallet NAME', I18n.t('option.wallet')) do |wallet|
options[:wallet] = wallet
end
end.parse!
config = MPW::Config.new(options[:config])
cli = MPW::Cli.new(config)
cli.load_config
cli.get_wallet(options[:wallet])
cli.decrypt
cli.delete(values)

64
bin/mpw-export
View file

@ -1,64 +0,0 @@
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
require 'optparse'
require 'mpw/config'
require 'mpw/cli'
# --------------------------------------------------------- #
# Options
# --------------------------------------------------------- #
options = {}
values = {}
OptionParser.new do |opts|
opts.banner = "#{I18n.t('option.usage')}: mpw wallet [options]"
opts.on('-c', '--config PATH', I18n.t('option.config')) do |config|
options[:config] = config
end
opts.on('-f', '--file PATH', I18n.t('option.file_export')) do |file|
options[:file] = file
end
opts.on('-g', '--group GROUP', I18n.t('option.group')) do |group|
values[:group] = group
end
opts.on('-h', '--help', I18n.t('option.help')) do
puts opts
exit 0
end
opts.on('-p', '--pattern PATTERN', I18n.t('option.pattern')) do |pattern|
values[:pattern] = pattern
end
opts.on('-w', '--wallet NAME', I18n.t('option.wallet')) do |wallet|
options[:wallet] = wallet
end
end.parse!
config = MPW::Config.new(options[:config])
cli = MPW::Cli.new(config)
cli.load_config
cli.get_wallet(options[:wallet])
cli.decrypt
cli.export(options[:file], values)

49
bin/mpw-genpwd
View file

@ -1,49 +0,0 @@
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
require 'optparse'
require 'mpw/mpw'
options = {}
OptionParser.new do |opts|
opts.banner = "#{I18n.t('option.usage')}: mpw passwd [options]"
opts.on('-h', '--help', I18n.t('option.help')) do
puts opts
exit 0
end
opts.on('-l', '--length NUMBER', I18n.t('option.length')) do |length|
options[:length] = length.to_i
end
opts.on('-n', '--numeric', I18n.t('option.numeric')) do
options[:numeric] = true
end
opts.on('-s', '--special-chars', I18n.t('option.special_chars')) do
options[:special] = true
end
opts.on('-a', '--alpha', I18n.t('option.alpha')) do
options[:alpha] = true
end
end.parse!
puts MPW::MPW.password(options)
exit 0

65
bin/mpw-import
View file

@ -1,65 +0,0 @@
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
require 'optparse'
require 'mpw/config'
require 'mpw/cli'
# --------------------------------------------------------- #
# Options
# --------------------------------------------------------- #
formats =
Dir["#{File.expand_path('../../lib/mpw/import', __FILE__)}/*.rb"]
.map { |v| File.basename(v, '.rb') }
.join(', ')
options = {
format: 'mpw'
}
OptionParser.new do |opts|
opts.banner = "#{I18n.t('option.usage')}: mpw import [options]"
opts.on('-c', '--config PATH', I18n.t('option.config')) do |config|
options[:config] = config
end
opts.on('-f', '--file PATH', I18n.t('option.file_import')) do |file|
options[:file] = file
end
opts.on('-F', '--format STRING', I18n.t('option.file_format', formats: formats)) do |format|
options[:format] = format
end
opts.on('-h', '--help', I18n.t('option.help')) do
puts opts
exit 0
end
opts.on('-w', '--wallet NAME', I18n.t('option.wallet')) do |wallet|
options[:wallet] = wallet
end
end.parse!
config = MPW::Config.new(options[:config])
cli = MPW::Cli.new(config)
cli.load_config
cli.get_wallet(options[:wallet])
cli.decrypt
cli.import(options[:file], options[:format])

60
bin/mpw-list
View file

@ -1,60 +0,0 @@
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
require 'optparse'
require 'mpw/config'
require 'mpw/cli'
# --------------------------------------------------------- #
# Options
# --------------------------------------------------------- #
options = {}
values = {}
OptionParser.new do |opts|
opts.banner = "#{I18n.t('option.usage')}: mpw list [options]"
opts.on('-c', '--config PATH', I18n.t('option.config')) do |config|
options[:config] = config
end
opts.on('-g', '--group NAME', I18n.t('option.group')) do |group|
values[:group] = group
end
opts.on('-h', '--help', I18n.t('option.help')) do
puts opts
exit 0
end
opts.on('-p', '--pattern PATTERN', I18n.t('option.pattern')) do |pattern|
values[:pattern] = pattern
end
opts.on('-w', '--wallet NAME', I18n.t('option.wallet')) do |wallet|
options[:wallet] = wallet
end
end.parse!
config = MPW::Config.new(options[:config])
cli = MPW::Cli.new(config)
cli.load_config
cli.get_wallet(options[:wallet])
cli.decrypt
cli.list(values)

92
bin/mpw-update
View file

@ -1,92 +0,0 @@
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
require 'optparse'
require 'mpw/config'
require 'mpw/cli'
# --------------------------------------------------------- #
# Options
# --------------------------------------------------------- #
values = {}
search = {}
options = {}
options[:text_editor] = false
OptionParser.new do |opts|
opts.banner = "#{I18n.t('option.usage')}: mpw update [options]"
opts.on('-c', '--config PATH', I18n.t('option.config')) do |config|
options[:config] = config
end
opts.on('-C', '--comment COMMENT', I18n.t('option.comment')) do |comment|
values[:comment] = comment
end
opts.on('-g', '--group NAME', I18n.t('option.group')) do |group|
search[:group] = group
end
opts.on('-G', '--new-group NAME', I18n.t('option.new_group')) do |group|
values[:group] = group
end
opts.on('-h', '--help', I18n.t('option.help')) do
puts opts
exit 0
end
opts.on('-o', '--otp-code CODE', I18n.t('option.otp_code')) do |otp|
values[:otp_key] = otp
end
opts.on('-p', '--pattern PATTERN', I18n.t('option.pattern')) do |pattern|
search[:pattern] = pattern
end
opts.on('-r', '--random', I18n.t('option.random_password')) do
options[:password] = true
end
opts.on('-t', '--text-editor', I18n.t('option.text_editor')) do
options[:text_editor] = true
end
opts.on('-u', '--url URL', I18n.t('option.url')) do |url|
values[:url] = url
end
opts.on('-U', '--user USER', I18n.t('option.user')) do |user|
values[:user] = user
end
opts.on('-w', '--wallet NAME', I18n.t('option.wallet')) do |wallet|
options[:wallet] = wallet
end
end.parse!
config = MPW::Config.new(options[:config])
cli = MPW::Cli.new(config)
options[:text_editor] = true if values.empty?
cli.load_config
cli.get_wallet(options[:wallet])
cli.decrypt
cli.update(options[:password], options[:text_editor], search, values)

90
bin/mpw-wallet
View file

@ -1,90 +0,0 @@
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
require 'optparse'
require 'mpw/config'
require 'mpw/cli'
# --------------------------------------------------------- #
# Options
# --------------------------------------------------------- #
options = {}
options[:delete] = false
OptionParser.new do |opts|
opts.banner = "#{I18n.t('option.usage')}: mpw wallet [options]"
opts.on('-a', '--add-gpg-key NAME', I18n.t('option.add_gpg_key')) do |gpg_key|
options[:gpg_key] = gpg_key
end
opts.on('-c', '--config PATH', I18n.t('option.config')) do |config|
options[:config] = config
end
opts.on('-d', '--delete-gpg-key NAME', I18n.t('option.delete_gpg_key')) do |gpg_key|
options[:gpg_key] = gpg_key
options[:delete] = true
end
opts.on('-h', '--help', I18n.t('option.help')) do
puts opts
exit 0
end
opts.on('-l', '--list', I18n.t('option.list')) do
options[:list] = true
end
opts.on('-L', '--list-keys', I18n.t('option.list_keys')) do
options[:list_keys] = true
end
opts.on('-p', '--path PATH', I18n.t('option.path')) do |path|
options[:path] = path
end
opts.on('-P', '--default-path', I18n.t('option.default_path')) do
options[:path] = 'default'
end
opts.on('-w', '--wallet NAME', I18n.t('option.wallet')) do |wallet|
options[:wallet] = wallet
end
end.parse!
config = MPW::Config.new(options[:config])
cli = MPW::Cli.new(config)
cli.load_config
if options.key?(:path)
cli.get_wallet(options[:wallet])
cli.set_wallet_path(options[:path])
elsif options.key?(:list_keys) || options.key?(:gpg_key)
cli.get_wallet(options[:wallet])
cli.decrypt
if options.key?(:list_keys)
cli.list_keys
elsif options.key?(:gpg_key)
options[:delete] ? cli.delete_key(options[:gpg_key]) : cli.add_key(options[:gpg_key])
end
else
cli.list_wallet
end

185
i18n/en.yml
View file

@ -1,191 +1,140 @@
--- ---
en: en:
error: error:
bad_class: "The object class isn't valid!"
config: config:
write: "Can't write the config file!" write: "Can't write the config file!"
load: "Checkconfig failed!" check: "Checkconfig failed!"
key_bad_format: "The key string isn't in the right format!" key_bad_format: "The key string isn't in good format!"
no_key_public: "You haven't entered the public key of %{key}!" no_key_public: "You haven't the public key of %{key}!"
genkey_gpg: genkey_gpg:
exception: "Can't create the GPG key!" exception: "Can't create the GPG key!"
name: "You must define a name for your GPG key!" name: "You must define a name for your GPG key!"
password: "You must define a password for your GPG key!" password: "You must define a password for your GPG key!"
empty: "The class is empty" delete:
id_no_exist: "Can't delete the item %{id}, it doesn't exist!"
export: "Can't export, unable to write in %{file}!" export: "Can't export, unable to write in %{file}!"
export_key: "Can't export the GPG key"
gpg_file: gpg_file:
decrypt: "Can't decrypt file!" decrypt: "Can't decrypt file!"
encrypt: "Can't encrypt the GPG file!" encrypt: "Can't encrypt the GPG file!"
mpw_file: mpw_file:
read_data: "Can't read the MPW file!" read_data: "Can't to read the MPW file!"
write_data: "Can't write the MPW file!" write_data: "Can't to write the MPW file!"
import: "Can't import, unable to read %{file}!" import: "Can't import, unable to read %{file}!"
update: update:
host_and_comment_empty: "You must define a host or a comment!" name_empty: "You must define a name!"
sync:
general: "An error is appeared durint the sync"
connection: "Connection fail!"
communication: "A communication problem with the server is appeared!"
download: "Can't download the file!"
not_authorized: "You haven't the access to remote file!"
upload: "Can't upload the file on the server!"
unknown: "An unknown error is occured!"
unknown_type: "The sync type is unknown"
warning: warning:
select: 'Your choice is not a valid item!' select: 'Your choice is not a valid element!'
command:
add: "Add a new item"
config: "Manage the general config"
copy: "Copy a login, password or OTP code"
delete: "Delete an item"
export: "Export the data in plain text"
genpwd: "Generate a password"
import: "Import data from a file"
list: "Print the items"
update: "Update an item"
wallet: "Manage the wallet config"
option: option:
add: "Add an item or key" add: "Add an item or key"
add_gpg_key: "Share the wallet with another GPG key"
alpha: "Use letter to create a password"
comment: "Specify a comment"
config: "Specify the configuration file to use" config: "Specify the configuration file to use"
clipboard: "Disable the clipboard feature"
default_path: "Move the wallet to the default directory"
default_wallet: "Specify the default wallet to use"
delete_gpg_key: "Delete wallet sharing with an other GPG key"
disable_alpha: "Don't use letters to create a password"
disable_numeric: "Don't use numbers to generate a password"
disable_pinmode: "Disable the pinentry mode"
disable_special_chars: "Don't use special char to create a password"
export: "Export a wallet in an yaml file" export: "Export a wallet in an yaml file"
file_export: "Specify the file to export data" file: "Specify a file, to use with the options [--import | --export | --add]"
file_format: "Format of import file (default: mpw; available: %{formats})" force: "No ask to confirm when you delete an item"
file_import: "Specify the file to import" generate_password: "Generate a random password (default 8 characters)"
force: "Do not ask confirmation when deleting an item"
generate_password: "Create a random password (default 8 characters)"
gpg_exe: "Set the gpg binary path to use"
gpg_key: "Specify a GPG key (ex: user@example.com)"
group: "Search the items with specified group" group: "Search the items with specified group"
help: "Show this help message" help: "Show this help message"
init: "Initialize mpw" id: "Specify an id, to use with the options [--delete | --update]"
import: "Import item from an yaml file" import: "Import item since a yaml file"
key: "Define the key name" key: "Specify the key name, to use with the options [--add | --delete | --update]"
lang: "Set the software language" no_sync: "Disable synchronization with the server"
length: "Size of the password"
list: "List the wallets"
list_keys: "List the GPG keys in wallet"
new_group: "Define a group for the item"
numeric: "Use number to create a password"
otp_code: "Set an otp key"
path: "Move the wallet in new specify directory"
pattern: "Given search pattern"
pinmode: "Enable pinentry mode (available with gpg >= 2.1)"
random_password: "Generate a random password"
setup: "Create a new configuration file" setup: "Create a new configuration file"
setup_wallet: "Create a new configuration file for a wallet" setup_wallet: "Create a new configuration file for a wallet"
special_chars: "Use special char to create a password" show: "Search and show the items"
show: "Search and display the items" show_all: "Show all items"
show_all: "Listing all items" remove: "Delete an item"
text_editor: "Use text editor to edit the item" update: "Update an item"
usage: "Use" usage: "Usage"
url: "Set an url (ex: https://example.com/path)"
user: "Set an user"
wallet: "Specify a wallet to use" wallet: "Specify a wallet to use"
wallet_dir: "Set the wallets folder"
form: form:
select: select: "Select the item: "
choice: "Select the item: "
error: "No item selected"
add_key: add_key:
valid: "Key has been added!" valid: "Key has been added!"
add_item: add_item:
name: "Item name (mandatory)" title: "Add a new item"
group: "Group name" name: "Enter the name: "
host: "Hostname or ip" group: "Enter the group (optional): "
protocol: "Connection protocol (ssh, http, ...)" server: "Enter the hostname or ip: "
login: "Connection ID" protocol: "Enter the protocol of the connection (ssh, http, other): "
password: "Password" login: "Enter the login connection: "
port: "Connection port" password: "Enter the the password: "
comment: "A comment" port: "Enter the connection port (optional): "
otp_key: "The OTP secret" comment: "Enter a comment (optional): "
valid: "Item has been added!" valid: "Item has been added!"
clipboard:
choice: "What do you want to copy ? [q = quit, p = password, l = login]: "
clean: "The clipboard has been cleaned."
login: "The login has been copied in clipboard."
password: "The password has been copied in clipboard for 30s!"
otp: "The OTP code has been copied %{time}s!"
url: "The URL has been copied in clipboard."
help:
name: "Help"
url: "Press <u> to copy URL"
login: "Press <l> to copy the login"
password: "Press <p> to copy the password"
otp_code: "Press <o> to copy the otp code"
quit: "Press <q> to quit"
delete_key: delete_key:
valid: "Key has been deleted!" valid: "Key has been deleted!"
delete_item: delete_item:
ask: "Are you sure you want to remove this item ?" ask: "Are you sure you want to remove the item %{id} ?"
valid: "The item has been removed!" valid: "The item %{id} has been removed!"
not_valid: "The item %{id} hasn't been removed, because it doesn't exist!"
import: import:
ask: "Are you sure you want to import this file %{file} ?" ask: "Are you sure you want to import this file %{file} ?"
file_empty: "The import file is empty!" valid: "The import is succesfull!"
file_not_exist: "The import file doesn't exist!"
format_unknown: "The import format '%{file_format} is unknown!"
valid: "The import is successful!"
not_valid: "No data to import!" not_valid: "No data to import!"
set_config:
valid: "The config file has been edited!"
set_wallet_path:
valid: "The wallet has been moved!"
setup_config: setup_config:
title: "Setup a new config file" title: "Setup a new config file"
lang: "Choose your language (en, fr, ...) [default=%{lang}]: " lang: "Choose your language (en, fr, ...) [default=%{lang}]: "
gpg_key: "Enter the GPG key [ex: test@host.local]: " gpg_key: "Enter the GPG key [ex: test@host.local]: "
gpg_exe: "Enter the executable GPG path (optional): "
wallet_dir: "Enter the wallets's folder path [default=%{home}/wallets]: " wallet_dir: "Enter the wallets's folder path [default=%{home}/wallets]: "
valid: "The config file has been created!" valid: "The config file has been created!"
setup_wallet:
title: "Wallet setup"
sync_type: "Synchronization type (ssh, ftp, or nil): "
sync_host: "Synchronization server: "
sync_port: "Port of the synchronization server: "
sync_user: "Username for the synchronization: "
sync_pwd: "Password for the synchronization: "
sync_path: "File path for the synchronization : "
valid: "The wallet config file has been created!"
setup_gpg_key: setup_gpg_key:
title: "Setup a GPG key" title: "Setup a GPG key"
ask: "Do you want to create your GPG key ? (Y/n)" ask: "Do you want create your GPG key ? (Y/n)"
no_create: "You must to create manually your GPG key or relaunch the software." no_create: "You must create manually your GPG key or relaunch the software."
name: "Your name and lastname: " name: "Your name and lastname: "
password: "A password for the GPG key: " password: "A password for the GPG key: "
confirm_password: "Confirm your password: " confirm_password: "Confirm your password: "
error_password: "Your passwords aren't identical!" error_password: "Your passwords aren't identical!"
length: "Size of the GPG key [default=2048]: " length: "Size of the GPG key [default=2048]: "
expire: "Expire time of the GPG key [default=0 (unlimited)]: " expire: "Expire time of the GPG key [default=0 (unlimited)]: "
wait: "Please wait until GPG key is created, this process can take a few minutes." wait: "Please waiting during the GPG key generate, this process can take few minutes."
valid: "Your GPG key has been created ;-)" valid: "Your GPG key has been created ;-)"
update_item: update_item:
name: "Item name (mandatory)" title: "Update an item"
group: "Group name" name: "Enter the name [%{name}]: "
host: "Hostname or ip" group: "Enter the group [%{group}]: "
protocol: "Connection protocol (ssh, http, ...)" server: "Enter the hostname or ip [%{server}]: "
login: "Login id" protocol: "Enter the protocol of the connection [%{protocol}]: "
password: "Password (leave empty if you don't want to update it)" login: "Enter the login connection [%{login}]: "
port: "Connection port" password: "Enter the the password: "
comment: "A comment" port: "Enter the connection port [%{port}]: "
otp_key: "Secret OTP (leave empty if you don't want to update it" comment: "Enter a comment [%{comment}]: "
valid: "Item has been updated!" valid: "Item has been updated!"
export: export:
valid: "The export in %{file} is successful!" valid: "The export in %{file} is succesfull!"
display: display:
comment: "Comment" comment: "Comment"
config: "Configuration"
error: "ERROR" error: "ERROR"
keys: "GPG keys" gpg_password: "GPG passphrase: "
gpg_password: "GPG password: "
group: "Group" group: "Group"
login: "Login" login: "Login"
name: "Name" name: "Name"
no_group: "Without group"
nothing: "No matches!" nothing: "No matches!"
otp_code: "OTP code"
password: "Password" password: "Password"
port: "Port" port: "Port"
protocol: "Protocol" protocol: "Protocol"
server: "Server" server: "Server"
wallets: "Wallets"
warning: "Warning" warning: "Warning"
formats: formats:

153
i18n/fr.yml
View file

@ -1,19 +1,18 @@
--- ---
fr: fr:
error: error:
bad_class: "La classe de l'objet n'est pas celle attendue!"
config: config:
write: "Impossible d'écrire le fichier de configuration!" write: "Impossible d'écrire le fichier de configuration!"
load: "Le fichier de configuration est invalide!" check: "Le fichier de configuration est invalide!"
key_bad_format: "La clé GPG est invalide!" key_bad_format: "La clé GPG est invalide!"
no_key_public: "Vous ne possédez pas la clé publique de %{key}!" no_key_public: "Vous ne possédez pas la clé publique de %{key}!"
genkey_gpg: genkey_gpg:
exception: "La création de la clé GPG n'a pas pu aboutir!" exception: "La création de la clé GPG n'a pas pu aboutir!"
name: "Vous devez définir un nom pour votre clé GPG!" name: "Vous devez définir un nom pour votre clé GPG!"
password: "Vous devez définir un mot de passe pour votre clé GPG!" password: "Vous devez définir un mot de passe pour votre clé GPG!"
empty: "La classe est vide" delete:
id_no_exist: "Impossible de supprimer l'élément %{id}, car il n'existe pas!"
export: "Impossible d'exporter les données dans le fichier %{file}!" export: "Impossible d'exporter les données dans le fichier %{file}!"
export_key: "Impossible d'exporter la clé GPG"
gpg_file: gpg_file:
decrypt: "Impossible de déchiffrer le fichier GPG!" decrypt: "Impossible de déchiffrer le fichier GPG!"
encrypt: "Impossible de chiffrer le fichier GPG!" encrypt: "Impossible de chiffrer le fichier GPG!"
@ -22,127 +21,82 @@ fr:
write_data: "Impossible d'écrire le fichier MPW!" write_data: "Impossible d'écrire le fichier MPW!"
import: "Impossible d'importer le fichier %{file}, car il n'est pas lisible!" import: "Impossible d'importer le fichier %{file}, car il n'est pas lisible!"
update: update:
host_and_comment_empty: "Vous devez définir un host ou un commentaire!" name_empty: "Vous devez définir un nom!"
sync:
general: "Une erreur est survenue durant la synchronisation"
connection: "La connexion n'a pu être établie!"
communication: "Un problème de communication avec le serveur est apparu!"
download: "Impossible de télécharger le fichier!"
not_authorized: "Vous n'avez pas les autorisations d'accès au fichier distant!"
upload: "Impossible d'envoyer le fichier sur le serveur!"
unknown: "Une erreur inconnue est survenue!"
unknown_type: "Le type de synchronisation est inconnu"
warning: warning:
select: "Votre choix n'est pas un élément valide!" select: "Votre choix n'est pas un élément valide!"
command:
add: "Ajoute un nouvel élément"
config: "Gère la configuration générale"
copy: "Copie un identifiant, un mot de passe ou un code OTP"
delete: "Supprimer un élément d'un portefeuille"
export: "Exporte les données"
genpwd: "Génére un mot de passe"
import: "Importe des données"
list: "Liste les éléments d'un portefeuille"
update: "Met à jour un élément"
wallet: "Gére la configuration d'un portefeuille"
option: option:
add: "Ajoute un élément ou une clé" add: "Ajoute un élément ou une clé"
add_gpg_key: "Partage le portefeuille avec une autre clé GPG"
alpha: "Utilise des lettres dans la génération d'un mot de passe"
config: "Spécifie le fichier de configuration à utiliser" config: "Spécifie le fichier de configuration à utiliser"
comment: "Spécifie un commentaire"
clipboard: "Désactive la fonction presse papier"
default_path: "Déplace le portefeuille dans le dossier par défaut"
default_wallet: "Spécifie le porte-feuille à utiliser par défaut"
delete_gpg_key: "Supprime le partage le portefeuille avec une autre clé GPG"
disable_alpha: "Désactive l'utilisation des lettres dans la génération d'un mot de passe"
disable_numeric: "Désactive l'utilisation des chiffre dans la génération d'un mot de passe"
disable_pinmode: "Désactive le mode pinentry"
disable_special_chars: "Désactive l'utilisation des charactères speciaux dans la génération d'un mot de passe"
export: "Exporte un portefeuille dans un fichier yaml" export: "Exporte un portefeuille dans un fichier yaml"
file_export: "Spécifie le fichier où exporter les données" file: "Spécifie un fichier, à utiliser avec les options [--import | --export | --add]"
file_format: "Format du fichier d'import (défault: mpw; disponible: %{formats})"
file_import: "Spécifie le fichier à importer"
force: "Ne demande pas de confirmation pour la suppression d'un élément" force: "Ne demande pas de confirmation pour la suppression d'un élément"
generate_password: "Génére un mot de passe aléatoire (défaut 8 caractères)" generate_password: "Génére un mot de passe aléatoire (défaut 8 caractères)"
gpg_exe: "Spécifie le chemin du binaire gpg à utiliser"
gpg_key: "Spécifie une clé GPG (ex: user@example.com)"
group: "Recherche les éléments appartenant au groupe spécifié" group: "Recherche les éléments appartenant au groupe spécifié"
help: "Affiche ce message d'aide" help: "Affiche ce message d'aide"
id: "Spécifie un identifiant, à utiliser avec les options [--delete | --update]"
import: "Importe des éléments depuis un fichier yaml" import: "Importe des éléments depuis un fichier yaml"
init: "Initialise mpw" key: "Spécifie le nom d'une clé, à utiliser avec les options [--add | --delete | --update]"
key: "Spécifie le nom d'une clé" no_sync: "Désactive la synchronisation avec le serveur"
lang: "Spécifie la langue du logiciel (ex: fr)"
length: "Taille du mot de passe"
list: "Liste les portefeuilles"
list_keys: "Liste les clés GPG dans le portefeuille"
new_group: "Spécifie le groupe de l'item"
numeric: "Utilise des chiffre dans la génération d'un mot de passe"
otp_code: "Spécifie un code OTP"
path: "Déplace le portefeuille dans un nouveau dossier"
pattern: "Motif de donnée à chercher"
pinmode: "Active le mode pinentry (valable avec gpg >= 2.1)"
random_password: "Génére un mot de passe aléatoire"
setup: "Création d'un nouveau fichier de configuration" setup: "Création d'un nouveau fichier de configuration"
setup_wallet: "Création d'un nouveau fichier de configuration pour un portefeuille" setup_wallet: "Création d'un nouveau fichier de configuration pour un portefeuille"
special_chars: "Utilise des charactères speciaux dans la génération d'un mot de passe"
show: "Recherche et affiche les éléments" show: "Recherche et affiche les éléments"
show_all: "Liste tous les éléments" show_all: "Affiche tous les éléments"
text_editor: "Active l'édition avec un éditeur de texte" remove: "Supprime un élément"
update: "Met à jour un élément"
usage: "Utilisation" usage: "Utilisation"
url: "Spécifie l'url (ex: http://example.com/path)"
user: "Spécifie un utilisateur"
wallet: "Spécifie le portefeuille à utiliser" wallet: "Spécifie le portefeuille à utiliser"
wallet_dir: "Spécifie le répertoire des portefeuilles"
form: form:
select: select: "Sélectionner l'élément: "
choice: "Sélectionner l'élément: "
error: "Aucun élément sélectionné"
add_key: add_key:
valid: "La clé a bien été ajoutée!" valid: "La clé a bien été ajoutée!"
add_item: add_item:
name: "Le nom de l'élément (obligatoire)" title: "Ajout d'un nouvel élément"
group: "Le nom du groupe" name: "Entrez le nom: "
host: "Le nom de domaine ou l'ip" group: "Entrez le groupe (optionnel): "
protocol: "Le protocole de connexion (ssh, http, ...)" server: "Entrez le nom de domaine ou l'ip: "
login: "L'identifiant de connexion" protocol: "Entrez le protocole de connexion (ssh, http, other): "
password: "Le mot de passe" login: "Entrez l'identifiant de connexion: "
port: "Le port de connexion" password: "Entrez le mot de passe: "
comment: "Un commentaire" port: "Entrez le port de connexion (optionnel): "
otp_key: "Le secret OTP" comment: "Entrez un commentaire (optionnel): "
valid: "L'élément a bien été ajouté!" valid: "L'élément a bien été ajouté!"
clipboard:
choice: "Que voulez-vous copier ? : "
clean: "Le presse papier a été nettoyé."
login: "L'identifiant a été copié dans le presse papier"
password: "Le mot de passe a été copié dans le presse papier pour 30s!"
otp: "Le code OTP a été copié dans le presse papier il est valable %{time}s!"
url: "L'URL a été copié dans le presse papier"
help:
name: "Aide"
url: "Pressez <u> pour copier l'URL"
login: "Pressez <l> pour copier l'identifiant"
password: "Pressez <p> pour copier le mot de passe"
otp_code: "Pressez <o> pour copier le code OTP"
quit: "Pressez <q> pour quitter"
delete_key: delete_key:
valid: "La clé a bien été supprimée!" valid: "La clé a bien été supprimée!"
delete_item: delete_item:
ask: "Êtes vous sûre de vouloir supprimer l'élément ?" ask: "Êtes vous sûre de vouloir supprimer l'élément %{id} ?"
valid: "L'élément a bien été supprimé!" valid: "L'élément %{id} a bien été supprimé!"
not_valid: "L'élément %{id} n'a pu être supprimé, car il n'existe pas!"
import: import:
ask: "Êtes vous sûre de vouloir importer le fichier %{file} ?" ask: "Êtes vous sûre de vouloir importer le fichier %{file} ?"
file_empty: "Le fichier d'import est vide!"
file_not_exist: "Le fichier d'import n'existe pas"
format_unknown: "Le format d'import '%{file_format}' est inconnu!"
valid: "L'import est un succès!" valid: "L'import est un succès!"
not_valid: "Aucune donnée à importer!" not_valid: "Aucune donnée à importer!"
set_config:
valid: "Le fichier de configuration a bien été modifié!"
set_wallet_path:
valid: "Le portefeuille a bien été déplacé!"
setup_config: setup_config:
title: "Création d'un nouveau fichier de configuration" title: "Création d'un nouveau fichier de configuration"
lang: "Choisissez votre langue (en, fr, ...) [défaut=%{lang}]: " lang: "Choisissez votre langue (en, fr, ...) [défaut=%{lang}]: "
gpg_key: "Entrez la clé GPG [ex: test@host.local]: " gpg_key: "Entrez la clé GPG [ex: test@host.local]: "
gpg_exe: "Entrez le chemin de l'exécutable GPG (optionnel): "
wallet_dir: "Entrez le chemin du répertoire qui contiendra les porte-feuilles de mot de passe [défaut=%{home}/wallets]: " wallet_dir: "Entrez le chemin du répertoire qui contiendra les porte-feuilles de mot de passe [défaut=%{home}/wallets]: "
valid: "Le fichier de configuration a bien été créé!" valid: "Le fichier de configuration a bien été créé!"
setup_wallet:
title: "Configuration du porte-feuille"
sync_type: "Type de synchronisation (ssh, ftp): "
sync_host: "Serveur: "
sync_port: "Port: "
sync_user: "Utilisateur: "
sync_pwd: "Mot de passe: "
sync_path: "Chemin du fichier: "
valid: "Le fichier de configuration du porte-feuille a bien été créé!"
setup_gpg_key: setup_gpg_key:
title: "Configuration d'une nouvelle clé GPG" title: "Configuration d'une nouvelle clé GPG"
ask: "Voulez vous créer votre clé GPG ? (O/n)" ask: "Voulez vous créer votre clé GPG ? (O/n)"
@ -156,36 +110,31 @@ fr:
wait: "Veuillez patienter durant la génération de votre clé GPG, ce processus peut prendre quelques minutes." wait: "Veuillez patienter durant la génération de votre clé GPG, ce processus peut prendre quelques minutes."
valid: "Votre clé GPG a bien été créée ;-)" valid: "Votre clé GPG a bien été créée ;-)"
update_item: update_item:
name: "Le nom de l'élément (obligatoire)" title: "Mis à jour d'un élément"
group: "Le nom du groupe" name: "Entrez le nom [%{name}]: "
host: "Le nom de domaine ou l'ip" group: "Entrez le groupe [%{group}]: "
protocol: "Le protocole de connexion (ssh, http, ...)" server: "Entrez le nom de domaine ou l'ip du serveur [%{server}]: "
login: "L'identifiant de connexion" protocol: "Entrez le protocole de connexion [%{protocol}]: "
password: "Le mot de passe (laissez vide si vous ne voulez pas le changer)" login: "Entrez votre identifiant de connexion [%{login}]: "
port: "Le port de connexion" password: "Entrez le mot de passe: "
comment: "Un commentaire" port: "Entrez un port de connexion [%{port}]: "
otp_key: "Le secret OTP (laissez vide si vous ne voulez pas le changer)" comment: "Entrez un commentaire [%{comment}]: "
valid: "L'élément a bien été mis à jour!" valid: "L'élément a bien été mis à jour!"
export: export:
valid: "L'export dans %{file} est un succès!" valid: "L'export dans %{file} est un succès!"
display: display:
comment: "Commentaire" comment: "Commentaire"
config: "Configuration"
error: "ERREUR" error: "ERREUR"
keys: "Clés GPG"
gpg_password: "Mot de passe GPG: " gpg_password: "Mot de passe GPG: "
group: "Groupe" group: "Groupe"
login: "Identifiant" login: "Identifiant"
name: "Nom" name: "Nom"
no_group: "Sans groupe"
nothing: "Aucun résultat!" nothing: "Aucun résultat!"
otp_code: "Code OTP"
password: "Mot de passe" password: "Mot de passe"
port: "Port" port: "Port"
protocol: "Protocol" protocol: "Protocol"
server: "Serveur" server: "Serveur"
wallets: "Porte-feuilles"
warning: "Warning" warning: "Warning"
formats: formats:

623
lib/mpw/cli.rb
View file

@ -1,623 +0,0 @@
#
# Copyright:: 2013, Adrien Waksberg
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
require 'readline'
require 'locale'
require 'i18n'
require 'colorize'
require 'highline/import'
require 'clipboard'
require 'tmpdir'
require 'mpw/item'
require 'mpw/mpw'
module MPW
class Cli
# @param config [Config]
def initialize(config)
@config = config
end
# Change a parameter int the config after init
# @param options [Hash] param to change
def set_config(options)
@config.setup(options)
puts I18n.t('form.set_config.valid').to_s.green
rescue => e
puts "#{I18n.t('display.error')} #15: #{e}".red
exit 2
end
# Change the wallet path
# @param path [String] new path
def set_wallet_path(path)
@config.set_wallet_path(path, @wallet)
puts I18n.t('form.set_wallet_path.valid').to_s.green
rescue => e
puts "#{I18n.t('display.error')} #19: #{e}".red
exit 2
end
# Create a new config file
# @param options [Hash]
def setup(options)
options[:lang] = options[:lang] || Locale::Tag.parse(ENV['LANG']).to_simple.to_s[0..1]
I18n.locale = options[:lang].to_sym
@config.setup(options)
load_config
puts I18n.t('form.setup_config.valid').to_s.green
rescue => e
puts "#{I18n.t('display.error')} #8: #{e}".red
exit 2
end
# Setup a new GPG key
# @param gpg_key [String] gpg key name
def setup_gpg_key(gpg_key)
return if @config.check_gpg_key?
password = ask(I18n.t('form.setup_gpg_key.password')) { |q| q.echo = false }
confirm = ask(I18n.t('form.setup_gpg_key.confirm_password')) { |q| q.echo = false }
raise I18n.t('form.setup_gpg_key.error_password') if password != confirm
@password = password.to_s
puts I18n.t('form.setup_gpg_key.wait')
@config.setup_gpg_key(@password, gpg_key)
puts I18n.t('form.setup_gpg_key.valid').to_s.green
rescue => e
puts "#{I18n.t('display.error')} #8: #{e}".red
exit 2
end
# List gpg keys in wallet
def list_keys
table_list('keys', @mpw.list_keys)
end
# List config
def list_config
config = {
'lang' => @config.lang,
'gpg_key' => @config.gpg_key,
'default_wallet' => @config.default_wallet,
'wallet_dir' => @config.wallet_dir,
'pinmode' => @config.pinmode,
'gpg_exe' => @config.gpg_exe
}
@config.wallet_paths.each { |k, v| config["path_wallet_#{k}"] = "#{v}/#{k}.mpw" }
@config.password.each { |k, v| config["password_#{k}"] = v }
table_list('config', config)
end
# Load config
def load_config
@config.load_config
rescue => e
puts "#{I18n.t('display.error')} #10: #{e}".red
exit 2
end
# Request the GPG password and decrypt the file
def decrypt
if defined?(@mpw)
@mpw.read_data
else
begin
@mpw = MPW.new(@config.gpg_key, @wallet_file, nil, @config.gpg_exe, @config.pinmode)
@mpw.read_data
rescue
@password = ask(I18n.t('display.gpg_password')) { |q| q.echo = false }
@mpw = MPW.new(@config.gpg_key, @wallet_file, @password, @config.gpg_exe, @config.pinmode)
@mpw.read_data
end
end
rescue => e
puts "#{I18n.t('display.error')} #11: #{e}".red
exit 2
end
# Format list on a table
# @param title [String] name of table
# @param list an array or hash
def table_list(title, list)
length = { k: 0, v: 0 }
if list.is_a?(Array)
i = 0
list = list.map do |item|
i += 1
[i, item]
end.to_h
end
list.each do |k, v|
length[:k] = k.to_s.length if length[:k] < k.to_s.length
length[:v] = v.to_s.length if length[:v] < v.to_s.length
end
puts "\n#{I18n.t("display.#{title}")}".red
print ' '
(length[:k] + length[:v] + 5).times { print '=' }
print "\n"
list.each do |k, v|
print " #{k}".cyan
(length[:k] - k.to_s.length + 1).times { print ' ' }
puts "| #{v}"
end
print "\n"
end
# Format items on a table
# @param items [Array]
def table_items(items = [])
group = '.'
i = 1
length_total = 10
data = { id: { length: 3, color: 'cyan' },
host: { length: 9, color: 'yellow' },
user: { length: 7, color: 'green' },
otp: { length: 4, color: 'white' },
comment: { length: 14, color: 'magenta' } }
items.each do |item|
data.each do |k, v|
case k
when :id, :otp
next
when :host
v[:length] = item.url.length + 3 if item.url.length >= v[:length]
else
v[:length] = item.send(k.to_s).to_s.length + 3 if item.send(k.to_s).to_s.length >= v[:length]
end
end
end
data[:id][:length] = items.length.to_s.length + 2 if items.length.to_s.length > data[:id][:length]
data.each_value { |v| length_total += v[:length] }
items.sort! { |a, b| a.group.to_s.downcase <=> b.group.to_s.downcase }
items.each do |item|
if group != item.group
group = item.group
if group.to_s.empty?
puts "\n#{I18n.t('display.no_group')}".red
else
puts "\n#{group}".red
end
print ' '
length_total.times { print '=' }
print "\n "
data.each do |k, v|
case k
when :id
print ' ID'
when :otp
print '| OTP'
else
print "| #{k.to_s.capitalize}"
end
(v[:length] - k.to_s.length).times { print ' ' }
end
print "\n "
length_total.times { print '=' }
print "\n"
end
print " #{i}".send(data[:id][:color])
(data[:id][:length] - i.to_s.length).times { print ' ' }
data.each do |k, v|
next if k == :id
print '| '
case k
when :otp
item.otp ? (print ' X ') : 4.times { print ' ' }
when :host
print "#{item.protocol}://".light_black if item.protocol
print item.host.send(v[:color])
print ":#{item.port}".light_black if item.port
(v[:length] - item.url.to_s.length).times { print ' ' }
else
print item.send(k.to_s).to_s.send(v[:color])
(v[:length] - item.send(k.to_s).to_s.length).times { print ' ' }
end
end
print "\n"
i += 1
end
print "\n"
end
# Display the query's result
# @param options [Hash] the options to search
def list(**options)
result = @mpw.list(options)
if result.empty?
puts I18n.t('display.nothing')
else
table_items(result)
end
end
# Get an item when multiple choice
# @param items [Array] list of items
# @return [Item] an item
def get_item(items)
return items[0] if items.length == 1
items.sort! { |a, b| a.group.to_s.downcase <=> b.group.to_s.downcase }
choice = ask(I18n.t('form.select.choice')).to_i
raise I18n.t('form.select.error') unless choice >= 1 && choice <= items.length
items[choice - 1]
end
# Print help message for clipboard mode
# @param item [Item]
def clipboard_help(item)
puts "----- #{I18n.t('form.clipboard.help.name')} -----".cyan
puts I18n.t('form.clipboard.help.url')
puts I18n.t('form.clipboard.help.login')
puts I18n.t('form.clipboard.help.password')
puts I18n.t('form.clipboard.help.otp_code') if item.otp
puts I18n.t('form.clipboard.help.quit')
end
# Copy in clipboard the login and password
# @param item [Item]
# @param clipboard [Boolean] enable clipboard
def clipboard(item, clipboard = true)
# Security: force quit after 90s
Thread.new do
sleep 90
exit
end
Kernel.loop do
choice = ask(I18n.t('form.clipboard.choice')).to_s
case choice
when 'q', 'quit'
break
when 'u', 'url'
if clipboard
Clipboard.copy(item.url)
puts I18n.t('form.clipboard.url').green
else
puts item.url
end
when 'l', 'login'
if clipboard
Clipboard.copy(item.user)
puts I18n.t('form.clipboard.login').green
else
puts item.user
end
when 'p', 'password'
if clipboard
Clipboard.copy(@mpw.get_password(item.id))
puts I18n.t('form.clipboard.password').yellow
Thread.new do
sleep 30
Clipboard.clear
end
else
puts @mpw.get_password(item.id)
end
when 'o', 'otp'
if !item.otp
clipboard_help(item)
next
elsif clipboard
Clipboard.copy(@mpw.get_otp_code(item.id))
else
puts @mpw.get_otp_code(item.id)
end
puts I18n.t('form.clipboard.otp', time: @mpw.get_otp_remaining_time).yellow
else
clipboard_help(item)
end
end
Clipboard.clear
rescue SystemExit, Interrupt
Clipboard.clear
end
# List all wallets
def list_wallet
wallets = @config.wallet_paths.keys
Dir.glob("#{@config.wallet_dir}/*.mpw").each do |f|
wallet = File.basename(f, '.mpw')
wallet += ' *'.green if wallet == @config.default_wallet
wallets << wallet
end
table_list('wallets', wallets)
end
# Display the wallet
# @param wallet [String] wallet name
def get_wallet(wallet = nil)
@wallet =
if wallet.to_s.empty?
wallets = Dir.glob("#{@config.wallet_dir}/*.mpw")
if wallets.length == 1
File.basename(wallets[0], '.mpw')
elsif !@config.default_wallet.to_s.empty?
@config.default_wallet
else
'default'
end
else
wallet
end
@wallet_file =
if @config.wallet_paths.key?(@wallet)
"#{@config.wallet_paths[@wallet]}/#{@wallet}.mpw"
else
"#{@config.wallet_dir}/#{@wallet}.mpw"
end
end
# Add a new public key
# @param key [String] key name or key file to add
def add_key(key)
@mpw.add_key(key)
@mpw.write_data
puts I18n.t('form.add_key.valid').to_s.green
rescue => e
puts "#{I18n.t('display.error')} #13: #{e}".red
end
# Add new public key
# @param key [String] key name to delete
def delete_key(key)
@mpw.delete_key(key)
@mpw.write_data
puts I18n.t('form.delete_key.valid').to_s.green
rescue => e
puts "#{I18n.t('display.error')} #15: #{e}".red
end
# Text editor interface
# @param template_name [String] template name
# @param item [Item] the item to edit
# @param password [Boolean] disable field password
# @return [Hash] the values for an item
def text_editor(template_name, password = false, item = nil, **options)
editor = ENV['EDITOR'] || 'nano'
opts = {}
template_file = "#{File.expand_path('../../../templates', __FILE__)}/#{template_name}.erb"
template = ERB.new(IO.read(template_file))
Dir.mktmpdir do |dir|
tmp_file = "#{dir}/#{template_name}.yml"
File.open(tmp_file, 'w') do |f|
f << template.result(binding)
end
system("#{editor} #{tmp_file}")
opts = YAML.load_file(tmp_file)
end
opts.delete_if { |_, v| v.to_s.empty? }
opts.each do |k, v|
options[k.to_sym] = v
end
options
end
# Form to add a new item
# @param password [Boolean] generate a random password
# @param text_editor [Boolean] enable text editor mode
# @param values [Hash] multiples value to set the item
def add(password = false, text_editor = false, **values)
options = text_editor('add_form', password, nil, values) if text_editor
item = Item.new(options)
options[:password] = MPW.password(@config.password) if password
@mpw.add(item)
@mpw.set_password(item.id, options[:password]) if options.key?(:password)
@mpw.set_otp_key(item.id, options[:otp_key]) if options.key?(:otp_key)
@mpw.write_data
puts I18n.t('form.add_item.valid').to_s.green
rescue => e
puts "#{I18n.t('display.error')} #13: #{e}".red
end
# Update an item
# @param password [Boolean] generate a random password
# @param text_editor [Boolean] enable text editor mode
# @param options [Hash] the options to search
# @param values [Hash] multiples value to set the item
def update(password = false, text_editor = false, options = {}, **values)
items = @mpw.list(options)
if items.empty?
puts I18n.t('display.nothing')
else
table_items(items) if items.length > 1
item = get_item(items)
values = text_editor('update_form', password, item, values) if text_editor
values[:password] = MPW.password(@config.password) if password
item.update(values)
@mpw.set_password(item.id, values[:password]) if values.key?(:password)
@mpw.set_otp_key(item.id, values[:otp_key]) if values.key?(:otp_key)
@mpw.write_data
puts I18n.t('form.update_item.valid').to_s.green
end
rescue => e
puts "#{I18n.t('display.error')} #14: #{e}".red
end
# Remove an item
# @param options [Hash] the options to search
def delete(**options)
items = @mpw.list(options)
if items.empty?
puts I18n.t('display.nothing')
else
table_items(items)
item = get_item(items)
confirm = ask("#{I18n.t('form.delete_item.ask')} (y/N) ").to_s
return unless confirm =~ /^(y|yes|YES|Yes|Y)$/
item.delete
@mpw.write_data
puts I18n.t('form.delete_item.valid').to_s.green
end
rescue => e
puts "#{I18n.t('display.error')} #16: #{e}".red
end
# Copy a password, otp, login
# @param clipboard [Boolean] enable clipboard
# @param options [Hash] the options to search
def copy(clipboard = true, **options)
items = @mpw.list(options)
if items.empty?
puts I18n.t('display.nothing')
else
table_items(items)
item = get_item(items)
clipboard(item, clipboard)
end
rescue => e
puts "#{I18n.t('display.error')} #14: #{e}".red
end
# Export the items in an yaml file
# @param file [String] the path of destination file
# @param options [Hash] options to search
def export(file, options)
file = 'export-mpw.yml' if file.to_s.empty?
items = @mpw.list(options)
data = {}
items.each do |item|
data.merge!(
item.id => {
'comment' => item.comment,
'created' => item.created,
'group' => item.group,
'last_edit' => item.last_edit,
'otp_key' => @mpw.get_otp_key(item.id),
'password' => @mpw.get_password(item.id),
'url' => item.url,
'user' => item.user
}
)
end
File.open(file, 'w') { |f| f << data.to_yaml }
puts I18n.t('form.export.valid', file: file).to_s.green
rescue => e
puts "#{I18n.t('display.error')} #17: #{e}".red
end
# Import items from an yaml file
# @param file [String] path of import file
# @param format [String] the software import file format
def import(file, format = 'mpw')
raise I18n.t('form.import.file_empty') if file.to_s.empty?
raise I18n.t('form.import.file_not_exist') unless File.exist?(file)
begin
require "mpw/import/#{format}"
rescue LoadError
raise I18n.t('form.import.format_unknown', file_format: format)
end
Import.send(format, file).each_value do |row|
item = Item.new(
comment: row['comment'],
group: row['group'],
url: row['url'],
user: row['user']
)
next if item.empty?
@mpw.add(item)
@mpw.set_password(item.id, row['password']) unless row['password'].to_s.empty?
@mpw.set_otp_key(item.id, row['otp_key']) unless row['otp_key'].to_s.empty?
end
@mpw.write_data
puts I18n.t('form.import.valid').to_s.green
rescue => e
puts "#{I18n.t('display.error')} #18: #{e}".red
end
end
end

286
lib/mpw/config.rb
View file

@ -1,190 +1,142 @@
# #!/usr/bin/ruby
# Copyright:: 2013, Adrien Waksberg # MPW is a software to crypt and manage your passwords
# # Copyright (C) 2016 Adrien Waksberg <mpw@yae.im>
# Licensed to the Apache Software Foundation (ASF) under one #
# or more contributor license agreements. See the NOTICE file # This program is free software; you can redistribute it and/or
# distributed with this work for additional information # modify it under the terms of the GNU General Public License
# regarding copyright ownership. The ASF licenses this file # as published by the Free Software Foundation; either version 2
# to you under the Apache License, Version 2.0 (the # of the License, or (at your option) any later version.
# "License"); you may not use this file except in compliance #
# with the License. You may obtain a copy of the License at # This program is distributed in the hope that it will be useful,
# # but WITHOUT ANY WARRANTY; without even the implied warranty of
# http://www.apache.org/licenses/LICENSE-2.0 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# # GNU General Public License for more details.
# Unless required by applicable law or agreed to in writing, #
# software distributed under the License is distributed on an # You should have received a copy of the GNU General Public License
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # along with this program; if not, write to the Free Software
# KIND, either express or implied. See the License for the # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
# specific language governing permissions and limitations
# under the License.
require 'gpgme' require 'gpgme'
require 'yaml' require 'yaml'
require 'i18n' require 'i18n'
require 'fileutils' require 'fileutils'
module MPW module MPW
class Config class Config
attr_accessor :error_msg
attr_accessor :error_msg
attr_accessor :gpg_key attr_accessor :key
attr_accessor :lang attr_accessor :lang
attr_accessor :config_dir attr_accessor :config_dir
attr_accessor :default_wallet attr_accessor :wallet_dir
attr_accessor :wallet_dir
attr_accessor :wallet_paths
attr_accessor :gpg_exe
attr_accessor :password
attr_accessor :pinmode
# @param config_file [String] path of config file # Constructor
def initialize(config_file = nil) # @args: config_file -> the specify config file
@config_file = config_file def initialize(config_file=nil)
@config_dir = @config_file = config_file
if RUBY_PLATFORM =~ /darwin/
"#{Dir.home}/Library/Preferences/mpw"
elsif RUBY_PLATFORM =~ /cygwin|mswin|mingw|bccwin|wince|emx/
"#{Dir.home}/AppData/Local/mpw"
else
"#{Dir.home}/.config/mpw"
end
@config_file = "#{@config_dir}/mpw.cfg" if @config_file.to_s.empty? if /darwin/ =~ RUBY_PLATFORM
end @config_dir = "#{Dir.home}/Library/Preferences/mpw"
elsif /cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM
@config_dir = "#{Dir.home}/AppData/Local/mpw"
else
@config_dir = "#{Dir.home}/.config/mpw"
end
if @config_file.nil? or @config_file.empty?
@config_file = "#{@config_dir}/mpw.cfg"
end
end
# Create a new config file # Create a new config file
# @param options [Hash] the value to set the config file # @args: key -> the gpg key to encrypt
def setup(**options) # lang -> the software language
gpg_key = options[:gpg_key] || @gpg_key # wallet_dir -> the directory where are the wallets password
lang = options[:lang] || @lang # @rtrn: true if le config file is create
wallet_dir = options[:wallet_dir] || @wallet_dir def setup(key, lang, wallet_dir)
default_wallet = options[:default_wallet] || @default_wallet
gpg_exe = options[:gpg_exe] || @gpg_exe
pinmode = options.key?(:pinmode) ? options[:pinmode] : @pinmode
password = {
numeric: true,
alpha: true,
special: false,
length: 16
}
%w[numeric special alpha length].each do |k| if not key =~ /[a-zA-Z0-9.-_]+\@[a-zA-Z0-9]+\.[a-zA-Z]+/
if options.key?("pwd_#{k}".to_sym) raise I18n.t('error.config.key_bad_format')
password[k.to_sym] = options["pwd_#{k}".to_sym] end
elsif !@password.nil? && @password.key?(k.to_sym)
password[k.to_sym] = @password[k.to_sym]
end
end
unless gpg_key =~ /[a-zA-Z0-9.-_]+\@[a-zA-Z0-9]+\.[a-zA-Z]+/ if wallet_dir.empty?
raise I18n.t('error.config.key_bad_format') wallet_dir = "#{@config_dir}/wallets"
end end
wallet_dir = "#{@config_dir}/wallets" if wallet_dir.to_s.empty? config = {'config' => {'key' => key,
config = { 'gpg_key' => gpg_key, 'lang' => lang,
'lang' => lang, 'wallet_dir' => wallet_dir,
'wallet_dir' => wallet_dir, }
'default_wallet' => default_wallet, }
'gpg_exe' => gpg_exe,
'password' => password,
'pinmode' => pinmode,
'wallet_paths' => @wallet_paths }
FileUtils.mkdir_p(@config_dir, mode: 0700) FileUtils.mkdir_p(wallet_dir, mode: 0700)
FileUtils.mkdir_p(wallet_dir, mode: 0700) File.open(@config_file, 'w') do |file|
file << config.to_yaml
end
rescue Exception => e
raise "#{I18n.t('error.config.write')}\n#{e}"
end
File.open(@config_file, 'w') do |file| # Setup a new gpg key
file << config.to_yaml # @args: password -> the GPG key password
end # name -> the name of user
rescue => e # length -> length of the GPG key
raise "#{I18n.t('error.config.write')}\n#{e}" # expire -> the time of expire to GPG key
end # @rtrn: true if the GPG key is create, else false
def setup_gpg_key(password, name, length = 4096, expire = 0)
if name.nil? or name.empty?
raise "#{I18n.t('error.config.genkey_gpg.name')}"
elsif password.nil? or password.empty?
raise "#{I18n.t('error.config.genkey_gpg.password')}"
end
# Setup a new gpg key param = ''
# @param password [String] gpg key password param << '<GnupgKeyParms format="internal">' + "\n"
# @param name [String] the name of user param << "Key-Type: DSA\n"
# @param length [Integer] length of the gpg key param << "Key-Length: #{length}\n"
# @param expire [Integer] time of expire to gpg key param << "Subkey-Type: ELG-E\n"
def setup_gpg_key(password, name, length = 4096, expire = 0) param << "Subkey-Length: #{length}\n"
raise I18n.t('error.config.genkey_gpg.name') if name.to_s.empty? param << "Name-Real: #{name}\n"
raise I18n.t('error.config.genkey_gpg.password') if password.to_s.empty? param << "Name-Comment: #{name}\n"
param << "Name-Email: #{@key}\n"
param << "Expire-Date: #{expire}\n"
param << "Passphrase: #{password}\n"
param << "</GnupgKeyParms>\n"
param = '' ctx = GPGME::Ctx.new
param << '<GnupgKeyParms format="internal">' + "\n" ctx.genkey(param, nil, nil)
param << "Key-Type: RSA\n" rescue Exception => e
param << "Key-Length: #{length}\n" raise "#{I18n.t('error.config.genkey_gpg.exception')}\n#{e}"
param << "Subkey-Type: ELG-E\n" end
param << "Subkey-Length: #{length}\n"
param << "Name-Real: #{name}\n"
param << "Name-Comment: #{name}\n"
param << "Name-Email: #{@gpg_key}\n"
param << "Expire-Date: #{expire}\n"
param << "Passphrase: #{password}\n"
param << "</GnupgKeyParms>\n"
ctx = GPGME::Ctx.new # Check the config file
ctx.genkey(param, nil, nil) # @rtrn: true if the config file is correct
rescue => e def is_valid?
raise "#{I18n.t('error.config.genkey_gpg.exception')}\n#{e}" config = YAML::load_file(@config_file)
end @key = config['config']['key']
@lang = config['config']['lang']
@wallet_dir = config['config']['wallet_dir']
# Load the config file raise if @key.empty? or @wallet_dir.empty?
def load_config
config = YAML.load_file(@config_file) I18n.locale = @lang.to_sym
@gpg_key = config['gpg_key']
@lang = config['lang']
@wallet_dir = config['wallet_dir']
@wallet_paths = config['wallet_paths'] || {}
@default_wallet = config['default_wallet']
@gpg_exe = config['gpg_exe']
@password = config['password'] || {}
@pinmode = config['pinmode'] || false
raise if @gpg_key.empty? || @wallet_dir.empty? return true
rescue
return false
end
I18n.locale = @lang.to_sym # Check if private key exist
rescue => e # @rtrn: true if the key exist, else false
raise "#{I18n.t('error.config.load')}\n#{e}" def check_gpg_key?
end ctx = GPGME::Ctx.new
ctx.each_key(@key, true) do
return true
end
# Check if private key exist return false
# @return [Boolean] true if the key exist, else false end
def check_gpg_key? end
ctx = GPGME::Ctx.new
ctx.each_key(@gpg_key, true) do
return true
end
false
end
# Change the path of one wallet
# @param path [String]new directory path
# @param wallet [String] wallet name
def set_wallet_path(path, wallet)
path = @wallet_dir if path == 'default'
path = File.absolute_path(path)
return if path == @wallet_dir && File.exist?("#{@wallet_dir}/#{wallet}.mpw")
return if path == @wallet_paths[wallet]
old_wallet_file =
if @wallet_paths.key?(wallet)
"#{@wallet_paths[wallet]}/#{wallet}.mpw"
else
"#{@wallet_dir}/#{wallet}.mpw"
end
FileUtils.mkdir_p(path) unless Dir.exist?(path)
FileUtils.mv(old_wallet_file, "#{path}/#{wallet}.mpw") if File.exist?(old_wallet_file)
if path == @wallet_dir
@wallet_paths.delete(wallet)
else
@wallet_paths[wallet] = path
end
setup
end
end
end end

53
lib/mpw/import/gorilla.rb
View file

@ -1,53 +0,0 @@
#
# Copyright:: 2013, Adrien Waksberg
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
require 'csv'
module MPW
module Import
# Import an export mpw file
# @param file [String] the file path to import
def self.gorilla(file)
data = {}
CSV.foreach(file, headers: true) do |row|
id = row['uuid']
comment =
if row['title'] && row['notes']
"#{row['title']} #{row['notes']}"
elsif row['title']
row['title']
elsif row['notes']
row['notes']
end
data[id] = {
'comment' => comment,
'group' => row['group'],
'password' => row['password'],
'url' => row['url'],
'user' => row['user']
}
end
data
end
end
end

53
lib/mpw/import/keepass.rb
View file

@ -1,53 +0,0 @@
#
# Copyright:: 2013, Adrien Waksberg
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
require 'csv'
module MPW
module Import
# Import an keepass2 export csv file
# @param file [String] the file path to import
def self.keepass(file)
data = {}
CSV.foreach(file, headers: true) do |row|
id = "#{row['Group']} #{row['Title']}"
comment =
if row['Title'] && row['Notes']
"#{row['Title']} #{row['Notes']}"
elsif row['Title']
row['Title']
elsif row['Notes']
row['Notes']
end
data[id] = {
'comment' => comment,
'group' => row['Group'],
'password' => row['Password'],
'url' => row['URL'],
'user' => row['Username']
}
end
data
end
end
end

31
lib/mpw/import/mpw.rb
View file

@ -1,31 +0,0 @@
#
# Copyright:: 2013, Adrien Waksberg
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
require 'yaml'
module MPW
module Import
# Import an export mpw file
# @param file [String] the file path to import
def self.mpw(file)
YAML.load_file(file)
end
end
end

48
lib/mpw/import/mpw_old.rb
View file

@ -1,48 +0,0 @@
#
# Copyright:: 2013, Adrien Waksberg
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
require 'yaml'
module MPW
module Import
# Import an export mpw file
# @param file [String] the file path to import
def self.mpw_old(file)
data = {}
YAML.load_file(file).each do |id, item|
url = ''
url += "#{item['protocol']}://" if item['protocol']
url += item['host']
url += ":#{item['port']}" if item['port']
data[id] = {
'comment' => item['comment'],
'group' => item['group'],
'otp' => item['otp'],
'password' => item['password'],
'url' => url,
'user' => item['user']
}
end
data
end
end
end

197
lib/mpw/item.rb
View file

@ -1,108 +1,119 @@
# #!/usr/bin/ruby
# Copyright:: 2013, Adrien Waksberg # MPW is a software to crypt and manage your passwords
# # Copyright (C) 2016 Adrien Waksberg <mpw@yae.im>
# Licensed to the Apache Software Foundation (ASF) under one #
# or more contributor license agreements. See the NOTICE file # This program is free software; you can redistribute it and/or
# distributed with this work for additional information # modify it under the terms of the GNU General Public License
# regarding copyright ownership. The ASF licenses this file # as published by the Free Software Foundation; either version 2
# to you under the Apache License, Version 2.0 (the # of the License, or (at your option) any later version.
# "License"); you may not use this file except in compliance #
# with the License. You may obtain a copy of the License at # This program is distributed in the hope that it will be useful,
# # but WITHOUT ANY WARRANTY; without even the implied warranty of
# http://www.apache.org/licenses/LICENSE-2.0 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# # GNU General Public License for more details.
# Unless required by applicable law or agreed to in writing, #
# software distributed under the License is distributed on an # You should have received a copy of the GNU General Public License
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # along with this program; if not, write to the Free Software
# KIND, either express or implied. See the License for the # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
# specific language governing permissions and limitations
# under the License.
require 'i18n' require 'i18n'
require 'uri'
module MPW module MPW
class Item class Item
attr_accessor :created
attr_accessor :comment
attr_accessor :group
attr_accessor :host
attr_accessor :id
attr_accessor :otp
attr_accessor :port
attr_accessor :protocol
attr_accessor :last_edit
attr_accessor :url
attr_accessor :user
# @param options [Hash] the option :host is required attr_accessor :error_msg
def initialize(**options)
@host = ''
if !options[:id] || !options[:created] attr_accessor :id
@id = generate_id attr_accessor :name
@created = Time.now.to_i attr_accessor :group
else attr_accessor :host
@id = options[:id] attr_accessor :protocol
@created = options[:created] attr_accessor :user
@last_edit = options[:last_edit] attr_accessor :port
options[:no_update_last_edit] = true attr_accessor :comment
end attr_accessor :last_edit
attr_accessor :last_sync
attr_accessor :created
update(options) # Constructor
end # Create a new item
# @args: options -> a hash of parameter
# raise an error if the hash hasn't the key name
def initialize(options={})
if not options.has_key?(:name) or options[:name].to_s.empty?
@error_msg = I18n.t('error.update.name_empty')
raise @error_msg
end
# Update the item if not options.has_key?(:id) or options[:id].to_s.empty? or not options.has_key?(:created) or options[:created].to_s.empty?
# @param options [Hash] @id = generate_id
def update(**options) @created = Time.now.to_i
unless options[:url] || options[:comment] else
raise I18n.t('error.update.host_and_comment_empty') @id = options[:id]
end @created = options[:created]
@last_edit = options[:last_edit]
options[:no_update_last_edit] = true
end
if options[:url] update(options)
uri = URI(options[:url]) end
@host = uri.host || options[:url]
@port = uri.port || nil
@protocol = uri.scheme || nil
@url = options[:url]
end
@comment = options[:comment] if options.key?(:comment) # Update the item
@group = options[:group] if options.key?(:group) # @args: options -> a hash of parameter
@last_edit = Time.now.to_i unless options.key?(:no_update_last_edit) # @rtrn: true if the item is update
@otp = options[:otp] if options.key?(:otp) def update(options={})
@user = options[:user] if options.key?(:user) if options.has_key?(:name) and options[:name].to_s.empty?
end @error_msg = I18n.t('error.update.name_empty')
return false
end
# Delete all data @name = options[:name] if options.has_key?(:name)
def delete @group = options[:group] if options.has_key?(:group)
@id = nil @host = options[:host] if options.has_key?(:host)
@comment = nil @protocol = options[:protocol] if options.has_key?(:protocol)
@created = nil @user = options[:user] if options.has_key?(:user)
@group = nil @port = options[:port].to_i if options.has_key?(:port) and not options[:port].to_s.empty?
@host = nil @comment = options[:comment] if options.has_key?(:comment)
@last_edit = nil @last_edit = Time.now.to_i if not options.has_key?(:no_update_last_edit)
@otp = nil
@port = nil
@protocol = nil
@url = nil
@user = nil
end
def empty? return true
@id.to_s.empty? end
end
def nil? # Update last_sync
false def set_last_sync
end @last_sync = Time.now.to_i
end
private # Delete all data
# @rtrn: true
def delete
@id = nil
@name = nil
@group = nil
@host = nil
@protocol = nil
@user = nil
@port = nil
@comment = nil
@created = nil
@last_edit = nil
@last_sync = nil
# Generate an random id return true
# @return [String] random string end
def generate_id
[*('A'..'Z'), *('a'..'z'), *('0'..'9')].sample(16).join def empty?
end return @name.to_s.empty?
end end
def nil?
return false
end
# Generate an random id
private
def generate_id
return ([*('A'..'Z'),*('a'..'z'),*('0'..'9')]).sample(16).join
end
end end
end

681
lib/mpw/mpw.rb
View file

@ -1,351 +1,460 @@
# #!/usr/bin/ruby
# Copyright:: 2013, Adrien Waksberg # MPW is a software to crypt and manage your passwords
# # Copyright (C) 2016 Adrien Waksberg <mpw@yae.im>
# Licensed to the Apache Software Foundation (ASF) under one #
# or more contributor license agreements. See the NOTICE file # This program is free software; you can redistribute it and/or
# distributed with this work for additional information # modify it under the terms of the GNU General Public License
# regarding copyright ownership. The ASF licenses this file # as published by the Free Software Foundation; either version 2
# to you under the Apache License, Version 2.0 (the # of the License, or (at your option) any later version.
# "License"); you may not use this file except in compliance #
# with the License. You may obtain a copy of the License at # This program is distributed in the hope that it will be useful,
# # but WITHOUT ANY WARRANTY; without even the implied warranty of
# http://www.apache.org/licenses/LICENSE-2.0 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# # GNU General Public License for more details.
# Unless required by applicable law or agreed to in writing, #
# software distributed under the License is distributed on an # You should have received a copy of the GNU General Public License
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # along with this program; if not, write to the Free Software
# KIND, either express or implied. See the License for the # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
# specific language governing permissions and limitations
# under the License.
require 'rubygems/package' require 'rubygems/package'
require 'gpgme' require 'gpgme'
require 'i18n' require 'i18n'
require 'yaml' require 'yaml'
require 'rotp'
require 'mpw/item'
#TODO
require "#{APP_ROOT}/../lib/mpw/item.rb"
module MPW module MPW
class MPW class MPW
# @param key [String] gpg key name
# @param wallet_file [String] path of the wallet file
# @param gpg_pass [String] password of the gpg key
# @param gpg_exe [String] path of the gpg executable
# @param pinmode [Boolean] enable the gpg pinmode
def initialize(key, wallet_file, gpg_pass = nil, gpg_exe = nil, pinmode = false)
@key = key
@gpg_pass = gpg_pass
@gpg_exe = gpg_exe
@wallet_file = wallet_file
@pinmode = pinmode
GPGME::Engine.set_info(GPGME::PROTOCOL_OpenPGP, @gpg_exe, "#{Dir.home}/.gnupg") unless @gpg_exe.to_s.empty? # Constructor
end def initialize(key, wallet_file, gpg_pass=nil)
@key = key
@gpg_pass = gpg_pass
@wallet_file = wallet_file
end
# Read mpw file # Read mpw file
def read_data def read_data
@data = [] @config = {}
@keys = {} @data = []
@passwords = {} @keys = {}
@otp_keys = {} @passwords = {}
data = nil data = nil
return unless File.exist?(@wallet_file) return if not File.exists?(@wallet_file)
Gem::Package::TarReader.new(File.open(@wallet_file)) do |tar| Gem::Package::TarReader.new(File.open(@wallet_file)) do |tar|
tar.each do |f| tar.each do |f|
case f.full_name case f.full_name
when 'wallet/meta.gpg' when 'wallet/config.gpg'
data = decrypt(f.read) @config = YAML.load(decrypt(f.read))
when %r{^wallet/keys/(?<key>.+)\.pub$} when 'wallet/meta.gpg'
key = Regexp.last_match('key') data = decrypt(f.read)
if GPGME::Key.find(:public, key).empty? when /^wallet\/keys\/(?<key>.+)\.pub$/
GPGME::Key.import(f.read, armor: true) key = Regexp.last_match('key')
end
@keys[key] = f.read if GPGME::Key.find(:public, key).length == 0
GPGME::Key.import(f.read, armor: true)
end
when %r{^wallet/passwords/(?<id>[a-zA-Z0-9]+)\.gpg$} @keys[key] = f.read
@passwords[Regexp.last_match('id')] = f.read
when %r{^wallet/otp_keys/(?<id>[a-zA-Z0-9]+)\.gpg$} when /^wallet\/passwords\/(?<id>[a-zA-Z0-9]+)\.gpg$/
@otp_keys[Regexp.last_match('id')] = f.read @passwords[Regexp.last_match('id')] = f.read
else
next
end
end
end
else if not data.nil? and not data.empty?
next YAML.load(data).each_value do |d|
end @data.push(Item.new(id: d['id'],
end name: d['name'],
end group: d['group'],
host: d['host'],
protocol: d['protocol'],
user: d['user'],
port: d['port'],
comment: d['comment'],
last_edit: d['last_edit'],
created: d['created'],
)
)
end
end
unless data.to_s.empty? add_key(@key) if @keys[@key].nil?
YAML.safe_load(data).each_value do |d| rescue Exception => e
@data.push( raise "#{I18n.t('error.mpw_file.read_data')}\n#{e}"
Item.new( end
id: d['id'],
group: d['group'],
user: d['user'],
url: d['url'],
otp: @otp_keys.key?(d['id']),
comment: d['comment'],
last_edit: d['last_edit'],
created: d['created']
)
)
end
end
add_key(@key) unless @keys.key?(@key) # Encrypt a file
rescue => e def write_data
raise "#{I18n.t('error.mpw_file.read_data')}\n#{e}" data = {}
end tmp_file = "#{@wallet_file}.tmp"
# Encrypt all data in tarball @data.each do |item|
def write_data next if item.empty?
data = {}
tmp_file = "#{@wallet_file}.tmp"
@data.each do |item| data.merge!(item.id => {'id' => item.id,
next if item.empty? 'name' => item.name,
'group' => item.group,
'host' => item.host,
'protocol' => item.protocol,
'user' => item.user,
'port' => item.port,
'comment' => item.comment,
'last_edit' => item.last_edit,
'created' => item.created,
}
)
end
data.merge!( Gem::Package::TarWriter.new(File.open(tmp_file, 'w+')) do |tar|
item.id => { data_encrypt = encrypt(data.to_yaml)
'id' => item.id, tar.add_file_simple('wallet/meta.gpg', 0400, data_encrypt.length) do |io|
'group' => item.group, io.write(data_encrypt)
'user' => item.user, end
'url' => item.url,
'comment' => item.comment,
'last_edit' => item.last_edit,
'created' => item.created
}
)
end
Gem::Package::TarWriter.new(File.open(tmp_file, 'w+')) do |tar| config = encrypt(@config.to_yaml)
data_encrypt = encrypt(data.to_yaml) tar.add_file_simple('wallet/config.gpg', 0400, config.length) do |io|
tar.add_file_simple('wallet/meta.gpg', 0400, data_encrypt.length) do |io| io.write(config)
io.write(data_encrypt) end
end
@passwords.each do |id, password| @passwords.each do |id, password|
tar.add_file_simple("wallet/passwords/#{id}.gpg", 0400, password.length) do |io| tar.add_file_simple("wallet/passwords/#{id}.gpg", 0400, password.length) do |io|
io.write(password) io.write(password)
end end
end end
@otp_keys.each do |id, key| @keys.each do |id, key|
tar.add_file_simple("wallet/otp_keys/#{id}.gpg", 0400, key.length) do |io| tar.add_file_simple("wallet/keys/#{id}.pub", 0400, key.length) do |io|
io.write(key) io.write(key)
end end
end end
end
@keys.each do |id, key| File.rename(tmp_file, @wallet_file)
tar.add_file_simple("wallet/keys/#{id}.pub", 0400, key.length) do |io| rescue Exception => e
io.write(key) File.unlink(tmp_file)
end
end
end
File.rename(tmp_file, @wallet_file) raise "#{I18n.t('error.mpw_file.write_data')}\n#{e}"
rescue => e end
File.unlink(tmp_file) if File.exist?(tmp_file)
raise "#{I18n.t('error.mpw_file.write_data')}\n#{e}" # Get a password
end # args: id -> the item id
def get_password(id)
password = decrypt(@passwords[id])
if /^\$[a-zA-Z0-9]{4,9}::(?<password>.+)$/ =~ password
return Regexp.last_match('password')
else
return password
end
end
# Get a password # Set a password
# @param id [String] the item id # args: id -> the item id
def get_password(id) # password -> the new password
password = decrypt(@passwords[id]) def set_password(id, password)
salt = MPW::password(Random.rand(4..9))
password = "$#{salt}::#{password}"
if /^\$[a-zA-Z0-9]{4,9}::(?<password>.+)$/ =~ password @passwords[id] = encrypt(password)
Regexp.last_match('password') end
else
password
end
end
# Set a new password for an item # Add a public key
# @param id [String] the item id # args: key -> new public key
# @param password [String] the new password # file -> public gpg file to import
def set_password(id, password) def add_key(key, file=nil)
salt = MPW.password(length: Random.rand(4..9)) if not file.nil? and File.exists?(file)
password = "$#{salt}::#{password}" data = File.open(file).read
GPGME::Key.import(data, armor: true)
else
data = GPGME::Key.export(key, armor: true).read
end
@passwords[id] = encrypt(password) if data.to_s.empty?
end raise I18n.t('error.export_key')
end
# Return the list of all gpg keys @keys[key] = data
# @return [Array] the gpg keys name end
def list_keys
@keys.keys
end
# Add a public key # Delete a public key
# @param key [String] new public key file or name # args: key -> public key to delete
def add_key(key) def delete_key(key)
if File.exist?(key) @keys.delete(key)
data = File.open(key).read end
key_import = GPGME::Key.import(data, armor: true)
key = GPGME::Key.get(key_import.imports[0].fpr).uids[0].email
else
data = GPGME::Key.export(key, armor: true).read
end
raise I18n.t('error.export_key') if data.to_s.empty? # Set config
# args: config -> a hash with config options
def set_config(config)
@config['sync'] = {} if @config['sync'].nil?
@keys[key] = data @config['sync']['type'] = config['sync']['type']
@passwords.each_key { |id| set_password(id, get_password(id)) } @config['sync']['host'] = config['sync']['host']
@otp_keys.each_key { |id| set_otp_key(id, get_otp_key(id)) } @config['sync']['port'] = config['sync']['port']
end @config['sync']['user'] = config['sync']['user']
@config['sync']['password'] = config['sync']['password']
@config['sync']['path'] = config['sync']['path']
@config['sync']['last_sync'] = @config['sync']['last_sync'].nil? ? 0 : @config['sync']['last_sync']
end
# Delete a public key # Add a new item
# @param key [String] public key to delete # @args: item -> Object MPW::Item
def delete_key(key) def add(item)
@keys.delete(key) if not item.instance_of?(Item)
@passwords.each_key { |id| set_password(id, get_password(id)) } raise I18n.t('error.bad_class')
@otp_keys.each_key { |id| set_otp_key(id, get_otp_key(id)) } elsif item.empty?
end raise I18n.t('error.add.empty')
else
@data.push(item)
end
end
# Add a new item # Search in some csv data
# @param item [Item] # @args: options -> a hash with paramaters
def add(item) # @rtrn: a list with the resultat of the search
raise I18n.t('error.bad_class') unless item.instance_of?(Item) def list(options={})
raise I18n.t('error.empty') if item.empty? result = []
@data.push(item) search = options[:search].to_s.downcase
end group = options[:group].to_s.downcase
# Search in some csv data @data.each do |item|
# @param options [Hash] next if item.empty?
# @return [Array] a list with the resultat of the search next if not group.empty? and not group.eql?(item.group.downcase)
def list(**options)
result = [] name = item.name.to_s.downcase
host = item.host.to_s.downcase
comment = item.comment.to_s.downcase
search = options[:pattern].to_s.downcase if not name =~ /^.*#{search}.*$/ and not host =~ /^.*#{search}.*$/ and not comment =~ /^.*#{search}.*$/
group = options[:group].to_s.downcase next
end
@data.each do |item| result.push(item)
next if item.empty? end
next unless group.empty? || group.eql?(item.group.to_s.downcase)
host = item.host.to_s.downcase return result
comment = item.comment.to_s.downcase end
next unless host =~ /^.*#{search}.*$/ || comment =~ /^.*#{search}.*$/ # Search in some csv data
# @args: id -> the id item
# @rtrn: a row with the result of the search
def search_by_id(id)
@data.each do |item|
return item if item.id == id
end
result.push(item) return nil
end end
result # Export to yaml
end # @args: file -> file where you export the data
def export(file)
data = {}
@data.each do |item|
data.merge!(item.id => {'id' => item.id,
'name' => item.name,
'group' => item.group,
'host' => item.host,
'protocol' => item.protocol,
'user' => item.user,
'password' => get_password(item.id),
'port' => item.port,
'comment' => item.comment,
'last_edit' => item.last_edit,
'created' => item.created,
}
)
end
# Search an item with an id File.open(file, 'w') {|f| f << data.to_yaml}
# @param id [String]the id item rescue Exception => e
# @return [Item] an item or nil raise "#{I18n.t('error.export', file: file)}\n#{e}"
def search_by_id(id) end
@data.each do |item|
return item if item.id == id
end
nil # Import to yaml
end # @args: file -> path to file import
def import(file)
YAML::load_file(file).each_value do |row|
item = Item.new(name: row['name'],
group: row['group'],
host: row['host'],
protocol: row['protocol'],
user: row['user'],
port: row['port'],
comment: row['comment'],
)
# Set a new opt key raise 'Item is empty' if item.empty?
# @param id [String] the item id
# @param key [String] the new key
def set_otp_key(id, key)
@otp_keys[id] = encrypt(key.to_s) unless key.to_s.empty?
end
# Get an opt key @data.push(item)
# @param id [String] the item id set_password(item.id, row['password'])
def get_otp_key(id) end
@otp_keys.key?(id) ? decrypt(@otp_keys[id]) : nil rescue Exception => e
end raise "#{I18n.t('error.import', file: file)}\n#{e}"
end
# Get an otp code # Get last sync
# @param id [String] the item id def get_last_sync
# @return [String] an otp code return @config['sync']['last_sync'].to_i
def get_otp_code(id) rescue
@otp_keys.key?(id) ? ROTP::TOTP.new(decrypt(@otp_keys[id])).now : 0 return 0
end end
# Get remaining time before expire otp code # Sync data with remote file
# @return [Integer] time in seconde def sync
def get_otp_remaining_time return if @config.empty? or @config['sync'].nil?
(Time.now.utc.to_i / 30 + 1) * 30 - Time.now.utc.to_i
end tmp_file = "#{@wallet_file}.sync"
last_sync = @config['last_sync'].to_i
# Generate a random password case @config['sync']['type']
# @param options [Hash] :length, :special, :alpha, :numeric when 'sftp', 'scp', 'ssh'
# @return [String] a random string require "#{APP_ROOT}/../lib/mpw/sync/ssh.rb"
def self.password(**options) sync = SyncSSH.new(@config['sync'])
length = when 'ftp'
if !options.include?(:length) || options[:length].to_i <= 0 require 'mpw/sync/ftp'
8 sync = SyncFTP.new(@config['sync'])
elsif options[:length].to_i >= 32_768 else
32_768 raise I18n.t('error.sync.unknown_type')
else end
options[:length].to_i
end
chars = [] sync.connect
chars += [*('!'..'?')] - [*('0'..'9')] if options[:special] sync.get(tmp_file)
chars += [*('A'..'Z'), *('a'..'z')] if options[:alpha]
chars += [*('0'..'9')] if options[:numeric]
chars = [*('A'..'Z'), *('a'..'z'), *('0'..'9')] if chars.empty?
result = '' remote = MPW.new(@key, tmp_file, @gpg_pass)
length.times do remote.read_data
result << chars.sample
end
result File.unlink(tmp_file) if File.exist?(tmp_file)
end
private return if remote.get_last_sync == get_last_sync
# Decrypt a gpg file if not remote.to_s.empty?
# @param data [String] data to decrypt @data.each do |item|
# @return [String] data decrypted update = false
def decrypt(data)
return nil if data.to_s.empty?
password = remote.list.each do |r|
if /^(1\.[0-9.]+|2\.0)(\.[0-9]+)?/ =~ GPGME::Engine.info.first.version || @pinmode next if item.id != r.id
{ password: @gpg_pass }
else
{ password: @gpg_pass,
pinentry_mode: GPGME::PINENTRY_MODE_LOOPBACK }
end
crypto = GPGME::Crypto.new(armor: true) # Update item
crypto if item.last_edit < r.last_edit
.decrypt(data, password) item.update(name: r.name,
.read.force_encoding('utf-8') group: r.group,
rescue => e host: r.host,
raise "#{I18n.t('error.gpg_file.decrypt')}\n#{e}" protocol: r.protocol,
end user: r.user,
port: r.port,
comment: r.comment
)
set_password(item.id, remote.get_password(item.id))
end
# Encrypt a file r.delete
# @param data [String] data to encrypt update = true
# @return [String] data encrypted
def encrypt(data)
recipients = []
crypto = GPGME::Crypto.new(armor: true, always_trust: true)
recipients.push(@key) break
@keys.each_key do |key| end
next if key == @key
recipients.push(key) # Remove an old item
end if not update and item.last_sync.to_i < last_sync and item.last_edit < last_sync
item.delete
end
end
end
# Add item
remote.list.each do |r|
next if r.last_edit <= last_sync
item = Item.new(id: r.id,
name: r.name,
group: r.group,
host: r.host,
protocol: r.protocol,
user: r.user,
port: r.port,
comment: r.comment,
created: r.created,
last_edit: r.last_edit
)
set_password(item.id, remote.get_password(item.id))
add(item)
end
remote = nil
@data.each do |item|
item.set_last_sync
end
@config['sync']['last_sync'] = Time.now.to_i
write_data
sync.update(@wallet_file)
rescue Exception => e
File.unlink(tmp_file) if File.exist?(tmp_file)
raise "#{I18n.t('error.sync.general')}\n#{e}"
end
# Generate a random password
# @args: length -> the length password
# @rtrn: a random string
def self.password(length=8)
if length.to_i <= 0
length = 8
else
length = length.to_i
end
result = ''
while length > 62 do
result << ([*('A'..'Z'),*('a'..'z'),*('0'..'9')]).sample(62).join
length -= 62
end
result << ([*('A'..'Z'),*('a'..'z'),*('0'..'9')]).sample(length).join
return result
end
# Decrypt a gpg file
# @args: data -> string to decrypt
private
def decrypt(data)
crypto = GPGME::Crypto.new(armor: true)
return crypto.decrypt(data, password: @gpg_pass).read.force_encoding('utf-8')
rescue Exception => e
raise "#{I18n.t('error.gpg_file.decrypt')}\n#{e}"
end
# Encrypt a file
# args: data -> string to encrypt
private
def encrypt(data)
recipients = []
crypto = GPGME::Crypto.new(armor: true, always_trust: true)
@keys.each_key do |key|
recipients.push(key)
end
recipients.push(@key) if not recipients.index(@key).nil?
return crypto.encrypt(data, recipients: recipients).read
rescue Exception => e
raise "#{I18n.t('error.gpg_file.encrypt')}\n#{e}"
end
crypto.encrypt(data, recipients: recipients).read end
rescue => e
raise "#{I18n.t('error.gpg_file.encrypt')}\n#{e}"
end
end
end end

68
lib/mpw/sync/ftp.rb Normal file
View file

@ -0,0 +1,68 @@
#!/usr/bin/ruby
# MPW is a software to crypt and manage your passwords
# Copyright (C) 2016 Adrien Waksberg <mpw@yae.im>
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
require 'i18n'
require 'net/ftp'
module MPW
class FTP
# Constructor
# @args: config -> the config
def initialize(config)
@host = config['host']
@user = config['user']
@password = config['password']
@path = config['path']
@port = config['port'].instance_of?(Integer) ? 22 : config['port']
end
# Connect to server
def connect
Net::FTP.open(@host) do |ftp|
ftp.login(@user, @password)
break
end
rescue Exception => e
raise "#{I18n.t('error.sync.connection')}\n#{e}"
end
# Get data on server
# @args: file_tmp -> the path where download the file
def get(file_tmp)
Net::FTP.open(@host) do |ftp|
ftp.login(@user, @password)
ftp.gettextfile(@path, file_tmp)
end
rescue Exception => e
raise "#{I18n.t('error.sync.download')}\n#{e}"
end
# Update the remote data
# @args: file_gpg -> the data to send on server
def update(file_gpg)
Net::FTP.open(@host) do |ftp|
ftp.login(@user, @password)
ftp.puttextfile(file_gpg, @path)
end
rescue Exception => e
raise "#{I18n.t('error.sync.upload')}\n#{e}"
end
end
end

67
lib/mpw/sync/ssh.rb Normal file
View file

@ -0,0 +1,67 @@
#!/usr/bin/ruby
# MPW is a software to crypt and manage your passwords
# Copyright (C) 2016 Adrien Waksberg <mpw@yae.im>
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
require 'i18n'
require 'net/ssh'
require 'net/sftp'
module MPW
class SyncSSH
# Constructor
# @args: config -> the config
def initialize(config)
@host = config['host']
@user = config['user']
@password = config['password']
@path = config['path']
@port = config['port'].instance_of?(Integer) ? 22 : config['port']
end
# Connect to server
def connect
Net::SSH.start(@host, @user, password: @password, port: @port) do
break
end
rescue Exception => e
raise "#{I18n.t('error.sync.connection')}\n#{e}"
end
# Get data on server
# @args: file_tmp -> the path where download the file
def get(file_tmp)
Net::SFTP.start(@host, @user, password: @password, port: @port) do |sftp|
sftp.lstat(@path) do |response|
sftp.download!(@path, file_tmp) if response.ok?
end
end
rescue Exception => e
raise "#{I18n.t('error.sync.download')}\n#{e}"
end
# Update the remote data
# @args: file_gpg -> the data to send on server
def update(file_gpg)
Net::SFTP.start(@host, @user, password: @password, port: @port) do |sftp|
sftp.upload!(file_gpg, @path)
end
rescue Exception => e
raise "#{I18n.t('error.sync.upload')}\n#{e}"
end
end
end

357
lib/mpw/ui/cli.rb Normal file
View file

@ -0,0 +1,357 @@
#!/usr/bin/ruby
# MPW is a software to crypt and manage your passwords
# Copyright (C) 2016 Adrien Waksberg <mpw@yae.im>
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
require 'readline'
require 'i18n'
require 'colorize'
require 'highline/import'
#TODO
require "#{APP_ROOT}/../lib/mpw/item.rb"
require "#{APP_ROOT}/../lib/mpw/mpw.rb"
module MPW
class Cli
# Constructor
# @args: config -> the config
# sync -> boolean for sync or not
def initialize(config, sync=true)
@config = config
@sync = sync
end
# Create a new config file
# @args: lang -> the software language
def setup(lang)
puts I18n.t('form.setup_config.title')
puts '--------------------'
language = ask(I18n.t('form.setup_config.lang', lang: lang)).to_s
key = ask(I18n.t('form.setup_config.gpg_key')).to_s
wallet_dir = ask(I18n.t('form.setup_config.wallet_dir', home: "#{@config.config_dir}")).to_s
if language.nil? or language.empty?
language = lang
end
I18n.locale = language.to_sym
@config.setup(key, lang, wallet_dir)
raise I18n.t('error.config.check') if not @config.is_valid?
puts "#{I18n.t('form.setup_config.valid')}".green
rescue Exception => e
puts "#{I18n.t('display.error')} #8: #{e}".red
exit 2
end
# Setup a new GPG key
def setup_gpg_key
puts I18n.t('form.setup_gpg_key.title')
puts '--------------------'
ask = ask(I18n.t('form.setup_gpg_key.ask')).to_s
if not ['Y', 'y', 'O', 'o'].include?(ask)
raise I18n.t('form.setup_gpg_key.no_create')
end
name = ask(I18n.t('form.setup_gpg_key.name')).to_s
password = ask(I18n.t('form.setup_gpg_key.password')) {|q| q.echo = false}
confirm = ask(I18n.t('form.setup_gpg_key.confirm_password')) {|q| q.echo = false}
if password != confirm
raise I18n.t('form.setup_gpg_key.error_password')
end
length = ask(I18n.t('form.setup_gpg_key.length')).to_s
expire = ask(I18n.t('form.setup_gpg_key.expire')).to_s
password = password.to_s
length = length.nil? or length.empty? ? 2048 : length.to_i
expire = expire.nil? or expire.empty? ? 0 : expire.to_i
puts I18n.t('form.setup_gpg_key.wait')
@config.setup_gpg_key(password, name, length, expire)
puts "#{I18n.t('form.setup_gpg_key.valid')}".green
rescue Exception => e
puts "#{I18n.t('display.error')} #8: #{e}".red
exit 2
end
# Setup wallet config for sync
def setup_wallet_config
config = {}
config['sync'] = {}
puts I18n.t('form.setup_wallet.title')
puts '--------------------'
config['sync']['type'] = ask(I18n.t('form.setup_wallet.sync_type')).to_s
config['sync']['host'] = ask(I18n.t('form.setup_wallet.sync_host')).to_s
config['sync']['port'] = ask(I18n.t('form.setup_wallet.sync_port')).to_s
config['sync']['user'] = ask(I18n.t('form.setup_wallet.sync_user')).to_s
config['sync']['password'] = ask(I18n.t('form.setup_wallet.sync_pwd')).to_s
config['sync']['path'] = ask(I18n.t('form.setup_wallet.sync_path')).to_s
@mpw.set_config(config)
@mpw.write_data
puts "#{I18n.t('form.setup_wallet.valid')}".green
rescue Exception => e
puts "#{I18n.t('display.error')} #10: #{e}".red
exit 2
end
# Request the GPG password and decrypt the file
def decrypt
if not defined?(@mpw)
@password = ask(I18n.t('display.gpg_password')) {|q| q.echo = false}
@mpw = MPW.new(@config.key, @wallet_file, @password)
end
@mpw.read_data
@mpw.sync if @sync
rescue Exception => e
puts "#{I18n.t('display.error')} #11: #{e}".red
exit 2
end
# Display the query's result
# @args: search -> the string to search
# protocol -> search from a particular protocol
def display(options={})
result = @mpw.list(options)
case result.length
when 0
puts I18n.t('display.nothing')
when 1
display_item(result.first)
else
i = 1
result.each do |item|
print "#{i}: ".cyan
print item.name
print " -> #{item.comment}".magenta if not item.comment.to_s.empty?
print "\n"
i += 1
end
choice = ask(I18n.t('form.select')).to_i
if choice >= 1 and choice < i
display_item(result[choice-1])
else
puts "#{I18n.t('display.warning')}: #{I18n.t('warning.select')}".yellow
end
end
end
# Display an item in the default format
# @args: item -> an array with the item information
def display_item(item)
puts '--------------------'.cyan
print 'Id: '.cyan
puts item.id
print "#{I18n.t('display.name')}: ".cyan
puts item.name
print "#{I18n.t('display.group')}: ".cyan
puts item.group
print "#{I18n.t('display.server')}: ".cyan
puts item.host
print "#{I18n.t('display.protocol')}: ".cyan
puts item.protocol
print "#{I18n.t('display.login')}: ".cyan
puts item.user
print "#{I18n.t('display.password')}: ".cyan
puts @mpw.get_password(item.id)
print "#{I18n.t('display.port')}: ".cyan
puts item.port
print "#{I18n.t('display.comment')}: ".cyan
puts item.comment
end
# Display the wallet
# @args: wallet -> the wallet name
def get_wallet(wallet=nil)
if wallet.to_s.empty?
wallets = Dir.glob("#{@config.wallet_dir}/*.mpw")
case wallets.length
when 0
puts I18n.t('display.nothing')
when 1
@wallet_file = wallets[0]
else
i = 1
wallets.each do |wallet|
print "#{i}: ".cyan
puts File.basename(wallet, '.mpw')
i += 1
end
choice = ask(I18n.t('form.select')).to_i
if choice >= 1 and choice < i
@wallet_file = wallets[choice-1]
else
puts "#{I18n.t('display.warning')}: #{I18n.t('warning.select')}".yellow
end
end
else
@wallet_file = "#{@config.wallet_dir}/#{wallet}.mpw"
end
end
# Add a new public key
# args: key -> the key name to add
# file -> gpg public file to import
def add_key(key, file=nil)
@mpw.add_key(key, file)
@mpw.write_data
@mpw.sync if @sync
puts "#{I18n.t('form.add_key.valid')}".green
rescue Exception => e
puts "#{I18n.t('display.error')} #13: #{e}".red
end
# Add new public key
# args: key -> the key name to delete
def delete_key(key)
@mpw.delete_key(key)
@mpw.write_data
@mpw.sync if @sync
puts "#{I18n.t('form.delete_key.valid')}".green
rescue Exception => e
puts "#{I18n.t('display.error')} #15: #{e}".red
end
# Form to add a new item
def add
options = {}
puts I18n.t('form.add_item.title')
puts '--------------------'
options[:name] = ask(I18n.t('form.add_item.name')).to_s
options[:group] = ask(I18n.t('form.add_item.group')).to_s
options[:host] = ask(I18n.t('form.add_item.server')).to_s
options[:protocol] = ask(I18n.t('form.add_item.protocol')).to_s
options[:user] = ask(I18n.t('form.add_item.login')).to_s
password = ask(I18n.t('form.add_item.password')).to_s
options[:port] = ask(I18n.t('form.add_item.port')).to_s
options[:comment] = ask(I18n.t('form.add_item.comment')).to_s
item = Item.new(options)
@mpw.add(item)
@mpw.set_password(item.id, password)
@mpw.write_data
@mpw.sync if @sync
puts "#{I18n.t('form.add_item.valid')}".green
end
# Update an item
# @args: id -> the item's id
def update(id)
item = @mpw.search_by_id(id)
if not item.nil?
options = {}
puts I18n.t('form.update_item.title')
puts '--------------------'
options[:name] = ask(I18n.t('form.update_item.name' , name: item.name)).to_s
options[:group] = ask(I18n.t('form.update_item.group' , group: item.group)).to_s
options[:host] = ask(I18n.t('form.update_item.server' , server: item.host)).to_s
options[:protocol] = ask(I18n.t('form.update_item.protocol', protocol: item.protocol)).to_s
options[:user] = ask(I18n.t('form.update_item.login' , login: item.user)).to_s
password = ask(I18n.t('form.update_item.password')).to_s
options[:port] = ask(I18n.t('form.update_item.port' , port: item.port)).to_s
options[:comment] = ask(I18n.t('form.update_item.comment' , comment: item.comment)).to_s
options.delete_if { |k,v| v.empty? }
item.update(options)
@mpw.set_password(item.id, password) if not password.empty?
@mpw.write_data
@mpw.sync if @sync
puts "#{I18n.t('form.update_item.valid')}".green
else
puts I18n.t('display.nothing')
end
rescue Exception => e
puts "#{I18n.t('display.error')} #14: #{e}".red
end
# Remove an item
# @args: id -> the item's id
# force -> no resquest a validation
def delete(id, force=false)
item = @mpw.search_by_id(id)
if item.nil?
puts I18n.t('form.delete_item.not_valid', id: id)
return
end
if not force
display_item(item)
confirm = ask("#{I18n.t('form.delete_item.ask', id: id)} (y/N) ").to_s
if not confirm =~ /^(y|yes|YES|Yes|Y)$/
return
end
end
item.delete
@mpw.write_data
@mpw.sync if @sync
puts "#{I18n.t('form.delete_item.valid', id: id)}".green
rescue Exception => e
puts "#{I18n.t('display.error')} #16: #{e}".red
end
# Export the items in a CSV file
# @args: file -> the destination file
def export(file)
@mpw.export(file)
puts "#{I18n.t('export.export.valid', file)}".green
rescue Exception => e
puts "#{I18n.t('display.error')} #17: #{e}".red
end
# Import items from a YAML file
# @args: file -> the import file
def import(file)
@mpw.import(file)
@mpw.write_data
puts "#{I18n.t('form.import.valid')}".green
rescue Exception => e
puts "#{I18n.t('display.error')} #18: #{e}".red
end
end
end

21
mpw.gemspec
View file

@ -1,3 +1,4 @@
# coding: utf-8
lib = File.expand_path('../lib', __FILE__) lib = File.expand_path('../lib', __FILE__)
$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib) $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
@ -7,22 +8,20 @@ Gem::Specification.new do |spec|
spec.authors = ['Adrien Waksberg'] spec.authors = ['Adrien Waksberg']
spec.email = ['mpw@yae.im'] spec.email = ['mpw@yae.im']
spec.summary = 'MPW is a software to crypt and manage your passwords' spec.summary = 'MPW is a software to crypt and manage your passwords'
spec.description = 'Manage your passwords in all security with MPW, we use GPG to encrypt your passwords' spec.description = 'Manage your passwords in all security with MPW, we use GPG to crypt your passwords'
spec.homepage = 'https://github.com/nishiki/manage-password' spec.homepage = 'https://github.com/nishiki/manage-password'
spec.license = 'GPL-2.0' spec.license = 'GPL-2.0'
spec.files = %x(git ls-files -z).split("\x0") spec.files = `git ls-files -z`.split("\x0")
spec.executables = ['mpw'] spec.executables = ['mpw']
spec.test_files = spec.files.grep(%r{^(test|spec|features)/}) spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
spec.require_paths = ['lib'] spec.require_paths = ['lib']
spec.required_ruby_version = '>= 2.1' spec.add_dependency "i18n"
spec.add_dependency "gpgme"
spec.add_dependency 'i18n', '~> 0.9', '>= 0.9.1' spec.add_dependency "highline"
spec.add_dependency 'gpgme', '~> 2.0', '>= 2.0.14' spec.add_dependency "locale"
spec.add_dependency 'highline', '~> 1.7', '>= 1.7.8' spec.add_dependency "colorize"
spec.add_dependency 'locale', '~> 2.1', '>= 2.1.2' spec.add_dependency "net-ssh"
spec.add_dependency 'colorize', '~> 0.8', '>= 0.8.1' spec.add_dependency "net-scp"
spec.add_dependency 'clipboard', '~> 1.1', '>= 1.1.1'
spec.add_dependency 'rotp', '~> 3.3', '>= 3.3.0'
end end

13
templates/add_form.erb
View file

@ -1,13 +0,0 @@
---
# <%= I18n.t('form.add_item.url') %>
url: <%= options[:url] %>
# <%= I18n.t('form.add_item.login') %>
user: <%= options[:user] %>
# <%= I18n.t('form.add_item.group') %>
group: <%= options[:group] %><% unless password %>
# <%= I18n.t('form.add_item.password') %>
password:<% end %>
# <%= I18n.t('form.add_item.comment') %>
comment: <%= options[:comment] %>
# <%= I18n.t('form.add_item.otp_key') %>
otp_key: <%= options[:otp] %>

13
templates/update_form.erb
View file

@ -1,13 +0,0 @@
---
# <%= I18n.t('form.update_item.url') %>
host: <% if options[:url] %><%= options[:url] %><% else %><%= item.url %><% end %>
# <%= I18n.t('form.update_item.login') %>
user: <% if options[:user] %><%= options[:user] %><% else %><%= item.user %><% end %><% unless password %>
# <%= I18n.t('form.update_item.password') %>
password: <% end %>
# <%= I18n.t('form.update_item.group') %>
group: <% if options[:group] %><%= options[:group] %><% else %><%= item.group %><% end %>
# <%= I18n.t('form.update_item.otp_key') %>
otp_key: <% if options[:otp_key] %><%= options[:otp_key] %><% end %>
# <%= I18n.t('form.update_item.comment') %>
comment: <% if options[:comment] %><%= options[:comment] %><% else %><%= item.comment %><% end %>

16
test/files/fixtures-import.yml
View file

@ -1,16 +0,0 @@
---
1:
url: https://fric.com
user: 230403
group: Bank
password: 5XdiTQOubRDw9B0aJoMlcEyL
otp_key: 330223432
comment: I love my bank
2:
url: https://assurance.com:443
user: user_2132
host: assurance.com
group: Assurance
password: DMyK6B3v4bWO52VzU7aTHIem
otp_key:
comment:

53
test/files/fixtures.yml
View file

@ -1,31 +1,32 @@
add: add_new:
url: 'https://example.com:8080' name: 'test_name'
group: 'Bank' group: 'test_group'
host: 'example.com' host: 'test_host'
protocol: 'https' protocol: 'test_protocol'
user: 'admin' user: 'test_user'
password: 'VmfnCN6pPIqgRIbc' password: 'test_password'
port: '8080' port: '42'
comment: 'the website' comment: 'test_comment'
import: add_existing:
id: 'TEST-ID-XXXXX' id: 'TEST-ID-XXXXX'
url: 'https://gogole.com:8081/toto' name: 'test_name_existing'
group: 'Cloud' group: 'test_group_existing'
host: 'gogole.com' host: 'test_host_existing'
protocol: 'https' protocol: 'test_protocol_existing'
user: 'gg-2304' user: 'test_user_existing'
password: 'TITl0kV9CDDa9sVK' password: 'test_password_existing'
port: '8081' port: '44'
comment: 'My little servers' comment: 'test_comment_existing'
created: 1386752948 created: 1386752948
update: update:
url: 'ssh://example2.com:2222' name: 'test_name_update'
group: 'Assurance' group: 'test_group_update'
host: 'example2.com' host: 'test_host_update'
protocol: 'ssh' protocol: 'test_protocol_update'
user: 'root' user: 'test_user_update'
password: 'kbSrbv4WlMaVxaZ7' password: 'test_password_update'
port: '2222' port: '43'
comment: 'i love ssh' comment: 'test_comment_update'

4
test/files/import-gorilla.txt
View file

@ -1,4 +0,0 @@
uuid,group,title,url,user,password,notes
49627979-e393-48c4-49ca-1cf66603238e,Bank,Fric,http://fric.com,12345,secret,money money
49627979-e393-48c4-49ca-1cf66603238f,,My little server,server.com,secret2,
49627979-e393-48c4-49ca-1cf66603238g,Cloud,,ssh://fric.com:4333,username,secret,bastion

3
test/files/import-keepass.txt
View file

@ -1,3 +0,0 @@
"Group","Title","Username","Password","URL","Notes"
"Racine","Bank","123456","ywcExJW8qmBVTSyi","http://bank.com/login","My little bank"
"Racine/Cloud","GAFAM","wesh","superpassword","localhost.local",""

35
test/files/import-mpw_old.txt
View file

@ -1,35 +0,0 @@
---
1:
host: fric.com
user: 12345
group: Bank
password: secret
protocol: http
port:
otp_key:
comment: Fric money money
last_edit: 1487623641
created: 1485729356
2:
host: server.com
user: sercret2
group:
password:
protocol:
port: 4222
otp_key:
comment: My little server
last_edit: 1487623641
created: 1485729356
3:
host: fric.com
user: username
group: Cloud
password:
protocol: ssh
port: 4333
otp_key:
comment: bastion
last_edit: 1487623641
created: 1485729356

3
test/files/test_import.csv Normal file
View file

@ -0,0 +1,3 @@
name,group,protocol,host,user,password,port,comment
test_name,test_group,test_protocol,test_host,test_user,test_password,42,test_comment
test_name_update,test_group_update,test_protocol_update,test_host_update,test_user_update,test_password_update,43,test_comment_update
1 name group protocol host user password port comment
2 test_name test_group test_protocol test_host test_user test_password 42 test_comment
3 test_name_update test_group_update test_protocol_update test_host_update test_user_update test_password_update 43 test_comment_update

23
test/files/test_import.yml Normal file
View file

@ -0,0 +1,23 @@
---
XWas7vpy0HerhOYd:
id: XWas7vpy0HerhOYd
name: test_name
group: test_group
host: test_host
protocol: test_protocol
user: test_user
password: test_password
port: 42
comment: test_comment
date: 1419858983
D7URyJENLa91jt0b:
id: D7URyJENLa91jt0b
name: test_name_update
group: test_group_update
host: test_host_update
protocol: test_protocol_update
user: test_user_update
password: test_password_update
port: 43
comment: test_comment_update
date: 1419858983

21
test/init.rb
View file

@ -1,21 +0,0 @@
require 'fileutils'
require 'gpgme'
FileUtils.rm_rf("#{Dir.home}/.config/mpw")
FileUtils.rm_rf("#{Dir.home}/.gnupg")
param = ''
param << '<GnupgKeyParms format="internal">' + "\n"
param << "Key-Type: RSA\n"
param << "Key-Length: 512\n"
param << "Subkey-Type: ELG-E\n"
param << "Subkey-Length: 512\n"
param << "Name-Real: test\n"
param << "Name-Comment: test\n"
param << "Name-Email: test2@example.com\n"
param << "Expire-Date: 0\n"
param << "Passphrase: password\n"
param << "</GnupgKeyParms>\n"
ctx = GPGME::Ctx.new
ctx.genkey(param, nil, nil)

256
test/test_cli.rb
View file

@ -1,256 +0,0 @@
require 'i18n'
require 'test/unit'
class TestConfig < Test::Unit::TestCase
def setup
if defined?(I18n.enforce_available_locales)
I18n.enforce_available_locales = true
end
I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
I18n.load_path = ["#{File.expand_path('../../i18n', __FILE__)}/en.yml"]
I18n.locale = :en
@password = 'password'
@fixtures = YAML.load_file('./test/files/fixtures.yml')
@gpg_key = 'test@example.com'
end
def test_00_init_config
output = %x(
echo "#{@password}\n#{@password}" | mpw config \
--init #{@gpg_key} \
2>/dev/null
)
assert_match(I18n.t('form.setup_config.valid'), output)
assert_match(I18n.t('form.setup_gpg_key.valid'), output)
end
def test_01_add_item
data = @fixtures['add']
output = %x(
echo #{@password} | mpw add \
--url #{data['url']} \
--user #{data['user']} \
--comment '#{data['comment']}' \
--group #{data['group']} \
--random \
2>/dev/null
)
assert_match(I18n.t('form.add_item.valid'), output)
output = %x(echo #{@password} | mpw list 2>/dev/null)
assert_match(%r{#{data['protocol']}://.+#{data['host']}.+:#{data['port']}}, output)
assert_match(data['user'], output)
assert_match(data['comment'], output)
assert_match(data['group'], output)
end
def test_02_search
data = @fixtures['add']
output = %x(echo #{@password} | mpw list --group #{data['group']} 2>/dev/null)
assert_match(%r{#{data['protocol']}://.+#{data['host']}.+:#{data['port']}}, output)
output = %x(echo #{@password} | mpw list --pattern #{data['host']} 2>/dev/null)
assert_match(%r{#{data['protocol']}://.+#{data['host']}.+:#{data['port']}}, output)
output = %x(echo #{@password} | mpw list --pattern #{data['comment']} 2>/dev/null)
assert_match(%r{#{data['protocol']}://.+#{data['host']}.+:#{data['port']}}, output)
output = %x(echo #{@password} | mpw list --group R1Pmfbp626TFpjlr 2>/dev/null)
assert_match(I18n.t('display.nothing'), output)
output = %x(echo #{@password} | mpw list --pattern h1IfnKqamaGM9oEX 2>/dev/null)
assert_match(I18n.t('display.nothing'), output)
end
def test_03_update_item
data = @fixtures['update']
output = %x(
echo #{@password} | mpw update \
-p #{@fixtures['add']['host']} \
--url #{data['url']} \
--user #{data['user']} \
--comment '#{data['comment']}' \
--new-group #{data['group']} \
2>/dev/null
)
assert_match(I18n.t('form.update_item.valid'), output)
output = %x(echo #{@password} | mpw list 2>/dev/null)
assert_match(%r{#{data['protocol']}://.+#{data['host']}.+:#{data['port']}}, output)
assert_match(data['user'], output)
assert_match(data['comment'], output)
assert_match(data['group'], output)
end
def test_04_delete_item
output = %x(
echo "#{@password}\ny" | mpw delete \
-p #{@fixtures['update']['host']} \
2>/dev/null
)
assert_match(I18n.t('form.delete_item.valid'), output)
output = %x(echo #{@password} | mpw list 2>/dev/null)
assert_match(I18n.t('display.nothing'), output)
end
def test_05_import_export
file_import = './test/files/fixtures-import.yml'
file_export = '/tmp/test-mpw.yml'
output = %x(echo #{@password} | mpw import --file #{file_import} 2>/dev/null)
assert_match(I18n.t('form.import.valid', file: file_import), output)
output = %x(echo #{@password} | mpw export --file #{file_export} 2>/dev/null)
assert_match(I18n.t('form.export.valid', file: file_export), output)
assert(File.exist?(file_export))
assert_equal(YAML.load_file(file_export).length, 2)
YAML.load_file(file_import).each_value do |import|
error = true
YAML.load_file(file_export).each_value do |export|
next if import['url'] != export['url']
%w[user group password protocol port otp_key comment].each do |key|
assert_equal(import[key].to_s, export[key].to_s)
end
error = false
break
end
assert(!error)
end
end
def test_06_copy
data = YAML.load_file('./test/files/fixtures-import.yml')[2]
output = %x(
echo "#{@password}\np\nq" | mpw copy \
--disable-clipboard \
-p #{data['host']} \
2>/dev/null
)
assert_match(data['password'], output)
end
def test_07_setup_wallet
gpg_key = 'test2@example.com'
output = %x(echo #{@password} | mpw wallet --add-gpg-key #{gpg_key} 2>/dev/null)
assert_match(I18n.t('form.add_key.valid'), output)
output = %x(echo #{@password} | mpw wallet --list-keys 2>/dev/null)
assert_match("| #{@gpg_key}", output)
assert_match("| #{gpg_key}", output)
output = %x(echo #{@password} | mpw wallet --delete-gpg-key #{gpg_key} 2>/dev/null)
assert_match(I18n.t('form.delete_key.valid'), output)
output = %x(echo #{@password} | mpw wallet --list-keys 2>/dev/null)
assert_match("| #{@gpg_key}", output)
assert_no_match(/\| #{gpg_key}/, output)
output = %x(mpw wallet)
assert_match('| default', output)
output = %x(mpw wallet --path '.')
assert_match(I18n.t('form.set_wallet_path.valid'), output)
output = %x(mpw config)
assert_match(%r{path_wallet_default.+\| #{Dir.pwd}/default.mpw}, output)
assert(File.exist?("#{Dir.pwd}/default.mpw"))
output = %x(mpw wallet)
assert_match('default', output)
output = %x(mpw wallet --default-path)
assert_match(I18n.t('form.set_wallet_path.valid'), output)
output = %x(mpw config)
assert_no_match(/path_wallet_default/, output)
end
def test_08_setup_config
gpg_key = 'test2@example.com'
gpg_exe = '/usr/bin/gpg2'
wallet_dir = '/tmp'
length = 24
wallet = 'work'
output = %x(
mpw config \
--gpg-exe #{gpg_exe} \
--key #{gpg_key} \
--enable-pinmode \
--disable-alpha \
--disable-special-chars \
--disable-numeric \
--length #{length} \
--wallet-dir #{wallet_dir} \
--default-wallet #{wallet}
)
assert_match(I18n.t('form.set_config.valid'), output)
output = %x(mpw config)
assert_match(/gpg_key.+\| #{gpg_key}/, output)
assert_match(/gpg_exe.+\| #{gpg_exe}/, output)
assert_match(/pinmode.+\| true/, output)
assert_match(/default_wallet.+\| #{wallet}/, output)
assert_match(/wallet_dir.+\| #{wallet_dir}/, output)
assert_match(/password_length.+\| #{length}/, output)
%w[numeric alpha special].each do |k|
assert_match(/password_#{k}.+\| false/, output)
end
output = %x(
mpw config \
--gpg-exe '' \
--key #{@gpg_key} \
--alpha \
--special-chars \
--numeric \
--disable-pinmode
)
assert_match(I18n.t('form.set_config.valid'), output)
output = %x(mpw config)
assert_match(/gpg_key.+\| #{@gpg_key}/, output)
assert_match(/pinmode.+\| false/, output)
%w[numeric alpha special].each do |k|
assert_match(/password_#{k}.+\| true/, output)
end
end
def test_09_generate_password
length = 24
output = %x(
mpw genpwd \
--length #{length} \
--alpha
)
assert_match(/[a-zA-Z]{#{length}}/, output)
output = %x(
mpw genpwd \
--length #{length} \
--numeric
)
assert_match(/[0-9]{#{length}}/, output)
output = %x(
mpw genpwd \
--length #{length} \
--special-chars
)
assert_no_match(/[a-zA-Z0-9]/, output)
end
end

79
test/test_config.rb
View file

@ -1,79 +0,0 @@
require 'mpw/config'
require 'test/unit'
require 'locale'
require 'i18n'
class TestConfig < Test::Unit::TestCase
def setup
lang = Locale::Tag.parse(ENV['LANG']).to_simple.to_s[0..1]
if defined?(I18n.enforce_available_locales)
I18n.enforce_available_locales = true
end
I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
I18n.load_path = Dir["#{File.expand_path('../../i18n', __FILE__)}/*.yml"]
I18n.default_locale = :en
I18n.locale = lang.to_sym
end
def test_00_config
data = {
gpg_key: 'test@example.com',
lang: 'en',
wallet_dir: '/tmp/test',
gpg_exe: ''
}
@config = MPW::Config.new
@config.setup(data)
@config.load_config
data.each do |k, v|
assert_equal(v, @config.send(k))
end
@config.setup_gpg_key('password', 'test@example.com', 2048)
assert(@config.check_gpg_key?)
end
def test_01_password
data = {
pwd_alpha: false,
pwd_numeric: false,
pwd_special: true,
pwd_length: 32
}
@config = MPW::Config.new
@config.load_config
assert_equal(@config.password[:length], 16)
assert(@config.password[:alpha])
assert(@config.password[:numeric])
assert(!@config.password[:special])
@config.setup(data)
@config.load_config
assert_equal(@config.password[:length], data[:pwd_length])
assert(!@config.password[:alpha])
assert(!@config.password[:numeric])
assert(@config.password[:special])
end
def test_02_wallet_paths
new_path = '/tmp/mpw-test'
@config = MPW::Config.new
@config.load_config
assert(!@config.wallet_paths['default'])
@config.set_wallet_path(new_path, 'default')
assert_equal(@config.wallet_paths['default'], new_path)
@config.set_wallet_path('default', 'default')
assert(!@config.wallet_paths['default'])
end
end

79
test/test_import.rb
View file

@ -1,79 +0,0 @@
require 'i18n'
require 'test/unit'
class TestImport < Test::Unit::TestCase
def setup
if defined?(I18n.enforce_available_locales)
I18n.enforce_available_locales = true
end
I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
I18n.load_path = ["#{File.expand_path('../../i18n', __FILE__)}/en.yml"]
I18n.locale = :en
@password = 'password'
end
def test_00_import_mpw_old
file = './test/files/import-mpw_old.txt'
format = 'mpw_old'
output = %x(
mpw import \
--file #{file} \
--format #{format} \
--wallet #{format}
)
assert_match(I18n.t('form.import.valid'), output)
output = %x(echo #{@password} | mpw list --group Bank --wallet #{format})
assert_match(%r{http://.*fric\.com.*12345.*Fric money money}, output)
output = %x(echo #{@password} | mpw list --group Cloud --wallet #{format})
assert_match(%r{ssh://.*fric\.com.*:4333.*username.*bastion}, output)
output = %x(echo #{@password} | mpw list --wallet #{format})
assert_match(/server\.com.*My little server/, output)
end
def test_01_import_gorilla
file = './test/files/import-gorilla.txt'
format = 'gorilla'
output = %x(
mpw import \
--file #{file} \
--format #{format} \
--wallet #{format}
)
assert_match(I18n.t('form.import.valid'), output)
output = %x(echo #{@password} | mpw list --group Bank --wallet #{format})
assert_match(%r{http://.*fric\.com.*12345.*Fric money money}, output)
output = %x(echo #{@password} | mpw list --group Cloud --wallet #{format})
assert_match(%r{ssh://.*fric\.com.*:4333.*username.*bastion}, output)
output = %x(echo #{@password} | mpw list --wallet #{format})
assert_match(/server\.com.*My little server/, output)
end
def test_02_import_keepass
file = './test/files/import-keepass.txt'
format = 'keepass'
output = %x(
mpw import \
--file #{file} \
--format #{format} \
--wallet #{format}
)
assert_match(I18n.t('form.import.valid'), output)
output = %x(echo #{@password} | mpw list --group 'Racine/Cloud' --wallet #{format})
assert_match(/localhost\.local.*wesh.*GAFAM/, output)
output = %x(echo #{@password} | mpw list --wallet #{format})
assert_match(%r{http://.*bank\.com.*123456.*Bank My little bank}, output)
end
end

313
test/test_item.rb
View file

@ -1,165 +1,218 @@
require 'mpw/item' #!/usr/bin/ruby
require_relative '../lib/Item'
require 'test/unit' require 'test/unit'
require 'yaml' require 'yaml'
class TestItem < Test::Unit::TestCase class TestItem < Test::Unit::TestCase
def setup def setup
if defined?(I18n.enforce_available_locales) @fixture_file = 'files/fixtures.yml'
I18n.enforce_available_locales = false @fixtures = YAML.load_file(@fixture_file)
end
if defined?(I18n.enforce_available_locales)
I18n.enforce_available_locales = false
end
I18n.load_path = Dir['./i18n/cli/*.yml'] I18n.load_path = Dir['../i18n/cli/*.yml']
I18n.default_locale = :en I18n.default_locale = :en
@fixtures = YAML.load_file('./test/files/fixtures.yml')
end
def test_00_add_without_name puts
assert_raise(RuntimeError) { MPW::Item.new } end
end
def test_01_add def test_00_add_without_name
data = { assert_raise(RuntimeError){MPW::Item.new}
group: @fixtures['add']['group'], end
user: @fixtures['add']['user'],
url: @fixtures['add']['url'],
comment: @fixtures['add']['comment']
}
item = MPW::Item.new(data) def test_01_add_new
data = {name: @fixtures['add_new']['name'],
group: @fixtures['add_new']['group'],
host: @fixtures['add_new']['host'],
protocol: @fixtures['add_new']['protocol'],
user: @fixtures['add_new']['user'],
password: @fixtures['add_new']['password'],
port: @fixtures['add_new']['port'],
comment: @fixtures['add_new']['comment'],
}
item = MPW::Item.new(data)
assert(!item.nil?) assert(!item.nil?)
assert(!item.empty?) assert(!item.empty?)
assert_equal(@fixtures['add']['url'], item.url) assert_equal(@fixtures['add_new']['name'], item.name)
assert_equal(@fixtures['add']['group'], item.group) assert_equal(@fixtures['add_new']['group'], item.group)
assert_equal(@fixtures['add']['host'], item.host) assert_equal(@fixtures['add_new']['host'], item.host)
assert_equal(@fixtures['add']['protocol'], item.protocol) assert_equal(@fixtures['add_new']['protocol'], item.protocol)
assert_equal(@fixtures['add']['user'], item.user) assert_equal(@fixtures['add_new']['user'], item.user)
assert_equal(@fixtures['add']['port'].to_i, item.port) assert_equal(@fixtures['add_new']['password'], item.password)
assert_equal(@fixtures['add']['comment'], item.comment) assert_equal(@fixtures['add_new']['port'].to_i, item.port)
end assert_equal(@fixtures['add_new']['comment'], item.comment)
end
def test_02_import def test_02_add_existing
data = { data = {id: @fixtures['add_existing']['id'],
id: @fixtures['import']['id'], name: @fixtures['add_existing']['name'],
group: @fixtures['import']['group'], group: @fixtures['add_existing']['group'],
user: @fixtures['import']['user'], host: @fixtures['add_existing']['host'],
url: @fixtures['import']['url'], protocol: @fixtures['add_existing']['protocol'],
comment: @fixtures['import']['comment'], user: @fixtures['add_existing']['user'],
created: @fixtures['import']['created'] password: @fixtures['add_existing']['password'],
} port: @fixtures['add_existing']['port'],
comment: @fixtures['add_existing']['comment'],
created: @fixtures['add_existing']['created'],
}
item = MPW::Item.new(data) item = MPW::Item.new(data)
assert(!item.nil?) assert(!item.nil?)
assert(!item.empty?) assert(!item.empty?)
assert_equal(@fixtures['import']['id'], item.id) assert_equal(@fixtures['add_existing']['id'], item.id)
assert_equal(@fixtures['import']['url'], item.url) assert_equal(@fixtures['add_existing']['name'], item.name)
assert_equal(@fixtures['import']['group'], item.group) assert_equal(@fixtures['add_existing']['group'], item.group)
assert_equal(@fixtures['import']['host'], item.host) assert_equal(@fixtures['add_existing']['host'], item.host)
assert_equal(@fixtures['import']['protocol'], item.protocol) assert_equal(@fixtures['add_existing']['protocol'], item.protocol)
assert_equal(@fixtures['import']['user'], item.user) assert_equal(@fixtures['add_existing']['user'], item.user)
assert_equal(@fixtures['import']['port'].to_i, item.port) assert_equal(@fixtures['add_existing']['password'], item.password)
assert_equal(@fixtures['import']['comment'], item.comment) assert_equal(@fixtures['add_existing']['port'].to_i, item.port)
assert_equal(@fixtures['import']['created'], item.created) assert_equal(@fixtures['add_existing']['comment'], item.comment)
end assert_equal(@fixtures['add_existing']['created'], item.created)
end
def test_03_update def test_03_update
data = { data = {name: @fixtures['add_new']['name'],
group: @fixtures['add']['group'], group: @fixtures['add_new']['group'],
user: @fixtures['add']['user'], host: @fixtures['add_new']['host'],
url: @fixtures['add']['url'], protocol: @fixtures['add_new']['protocol'],
comment: @fixtures['add']['comment'] user: @fixtures['add_new']['user'],
} password: @fixtures['add_new']['password'],
port: @fixtures['add_new']['port'],
comment: @fixtures['add_new']['comment'],
}
item = MPW::Item.new(data)
item = MPW::Item.new(data) assert(!item.nil?)
assert(!item.empty?)
assert(!item.nil?) created = item.created
assert(!item.empty?) last_edit = item.last_edit
created = item.created data = {name: @fixtures['update']['name'],
last_edit = item.last_edit group: @fixtures['update']['group'],
host: @fixtures['update']['host'],
protocol: @fixtures['update']['protocol'],
user: @fixtures['update']['user'],
password: @fixtures['update']['password'],
port: @fixtures['update']['port'],
comment: @fixtures['update']['comment'],
}
sleep(1)
assert(item.update(data))
data = { assert(!item.empty?)
group: @fixtures['update']['group'],
user: @fixtures['update']['user'],
url: @fixtures['update']['url'],
comment: @fixtures['update']['comment']
}
sleep(1) assert_equal(@fixtures['update']['name'], item.name)
assert(item.update(data)) assert_equal(@fixtures['update']['group'], item.group)
assert_equal(@fixtures['update']['host'], item.host)
assert_equal(@fixtures['update']['protocol'], item.protocol)
assert_equal(@fixtures['update']['user'], item.user)
assert_equal(@fixtures['update']['password'], item.password)
assert_equal(@fixtures['update']['port'].to_i, item.port)
assert_equal(@fixtures['update']['comment'], item.comment)
assert(!item.empty?) assert_equal(created, item.created)
assert_not_equal(last_edit, item.last_edit)
end
assert_equal(@fixtures['update']['url'], item.url) def test_04_update_with_empty_name
assert_equal(@fixtures['update']['group'], item.group) data = {name: @fixtures['add_new']['name'],
assert_equal(@fixtures['update']['host'], item.host) group: @fixtures['add_new']['group'],
assert_equal(@fixtures['update']['protocol'], item.protocol) host: @fixtures['add_new']['host'],
assert_equal(@fixtures['update']['user'], item.user) protocol: @fixtures['add_new']['protocol'],
assert_equal(@fixtures['update']['port'].to_i, item.port) user: @fixtures['add_new']['user'],
assert_equal(@fixtures['update']['comment'], item.comment) password: @fixtures['add_new']['password'],
port: @fixtures['add_new']['port'],
comment: @fixtures['add_new']['comment'],
}
item = MPW::Item.new(data)
assert_equal(created, item.created) assert(!item.nil?)
assert_not_equal(last_edit, item.last_edit) assert(!item.empty?)
end
def test_05_update_one_element last_edit = item.last_edit
data = {
group: @fixtures['add']['group'],
user: @fixtures['add']['user'],
url: @fixtures['add']['url'],
comment: @fixtures['add']['comment']
}
item = MPW::Item.new(data) sleep(1)
assert(!item.update({name: ''}))
assert(!item.nil?) assert_equal(last_edit, item.last_edit)
assert(!item.empty?) end
last_edit = item.last_edit def test_05_update_one_element
data = {name: @fixtures['add_new']['name'],
group: @fixtures['add_new']['group'],
host: @fixtures['add_new']['host'],
protocol: @fixtures['add_new']['protocol'],
user: @fixtures['add_new']['user'],
password: @fixtures['add_new']['password'],
port: @fixtures['add_new']['port'],
comment: @fixtures['add_new']['comment'],
}
item = MPW::Item.new(data)
sleep(1) assert(!item.nil?)
item.update(comment: @fixtures['update']['comment']) assert(!item.empty?)
assert_equal(@fixtures['add']['url'], item.url) last_edit = item.last_edit
assert_equal(@fixtures['add']['group'], item.group)
assert_equal(@fixtures['add']['host'], item.host)
assert_equal(@fixtures['add']['protocol'], item.protocol)
assert_equal(@fixtures['add']['user'], item.user)
assert_equal(@fixtures['add']['port'].to_i, item.port)
assert_equal(@fixtures['update']['comment'], item.comment)
assert_not_equal(last_edit, item.last_edit) sleep(1)
end assert(item.update({comment: @fixtures['update']['comment']}))
def test_05_delete assert_equal(@fixtures['add_new']['name'], item.name)
data = { assert_equal(@fixtures['add_new']['group'], item.group)
group: @fixtures['add']['group'], assert_equal(@fixtures['add_new']['host'], item.host)
user: @fixtures['add']['user'], assert_equal(@fixtures['add_new']['protocol'], item.protocol)
url: @fixtures['add']['url'], assert_equal(@fixtures['add_new']['user'], item.user)
comment: @fixtures['add']['comment'] assert_equal(@fixtures['add_new']['password'], item.password)
} assert_equal(@fixtures['add_new']['port'].to_i, item.port)
assert_equal(@fixtures['update']['comment'], item.comment)
assert_not_equal(last_edit, item.last_edit)
end
item = MPW::Item.new(data) def test_05_delete
data = {name: @fixtures['add_new']['name'],
group: @fixtures['add_new']['group'],
host: @fixtures['add_new']['host'],
protocol: @fixtures['add_new']['protocol'],
user: @fixtures['add_new']['user'],
password: @fixtures['add_new']['password'],
port: @fixtures['add_new']['port'],
comment: @fixtures['add_new']['comment'],
}
item = MPW::Item.new(data)
assert(!item.nil?) assert(!item.nil?)
assert(!item.empty?) assert(!item.empty?)
item.delete assert(item.delete)
assert(!item.nil?) assert(!item.nil?)
assert(item.empty?) assert(item.empty?)
assert_equal(nil, item.id) assert_equal(nil, item.id)
assert_equal(nil, item.url) assert_equal(nil, item.name)
assert_equal(nil, item.group) assert_equal(nil, item.group)
assert_equal(nil, item.host) assert_equal(nil, item.host)
assert_equal(nil, item.protocol) assert_equal(nil, item.protocol)
assert_equal(nil, item.user) assert_equal(nil, item.user)
assert_equal(nil, item.port) assert_equal(nil, item.password)
assert_equal(nil, item.comment) assert_equal(nil, item.port)
assert_equal(nil, item.created) assert_equal(nil, item.comment)
end assert_equal(nil, item.created)
end end
end

255
test/test_mpw.rb
View file

@ -1,130 +1,191 @@
require 'mpw/mpw' #!/usr/bin/ruby
require 'mpw/item'
require_relative '../lib/MPW'
require_relative '../lib/Item'
require 'test/unit' require 'test/unit'
require 'yaml' require 'yaml'
require 'csv' require 'csv'
class TestMPW < Test::Unit::TestCase class TestMPW < Test::Unit::TestCase
def setup def setup
wallet_file = 'default.gpg' fixture_file = 'files/fixtures.yml'
key = 'test@example.com'
password = 'password'
if defined?(I18n.enforce_available_locales) file_gpg = 'test.gpg'
I18n.enforce_available_locales = false key = ENV['MPW_TEST_KEY']
end
@mpw = MPW::MPW.new(key, wallet_file, password) puts
@fixtures = YAML.load_file('./test/files/fixtures.yml')
end
def test_00_decrypt_empty_file if defined?(I18n.enforce_available_locales)
@mpw.read_data I18n.enforce_available_locales = false
assert_equal(0, @mpw.list.length) end
end
def test_01_encrypt_empty_file File.delete(file_gpg) if File.exist?(file_gpg)
@mpw.read_data
@mpw.write_data
end
def test_02_add_item @mpw = MPW::MPW.new(file_gpg, key)
data = { @fixtures = YAML.load_file(fixture_file)
group: @fixtures['add']['group'], end
user: @fixtures['add']['user'],
url: @fixtures['add']['url'], def test_01_import_yaml
comment: @fixtures['add']['comment'] import_file = 'files/test_import.yml'
}
item = MPW::Item.new(data) assert(@mpw.import(import_file, :yaml))
assert_equal(2, @mpw.list.length)
assert(!item.nil?) item = @mpw.list[0]
assert(!item.empty?) assert_equal(@fixtures['add_new']['name'], item.name)
assert_equal(@fixtures['add_new']['group'], item.group)
assert_equal(@fixtures['add_new']['host'], item.host)
assert_equal(@fixtures['add_new']['protocol'], item.protocol)
assert_equal(@fixtures['add_new']['user'], item.user)
assert_equal(@fixtures['add_new']['password'], item.password)
assert_equal(@fixtures['add_new']['port'].to_i, item.port)
assert_equal(@fixtures['add_new']['comment'], item.comment)
end
@mpw.read_data def test_02_export_yaml
@mpw.add(item) import_file = 'files/test_import.yml'
@mpw.set_password(item.id, @fixtures['add']['password']) export_file = 'test_export.yml'
assert_equal(1, @mpw.list.length) assert(@mpw.import(import_file))
assert_equal(2, @mpw.list.length)
assert(@mpw.export(export_file, :yaml))
export = YAML::load_file(export_file)
assert_equal(2, export.length)
item = @mpw.list[0] result = export.values[0]
@fixtures['add'].each do |k, v| assert_equal(@fixtures['add_new']['name'], result['name'])
if k == 'password' assert_equal(@fixtures['add_new']['group'], result['group'])
assert_equal(v, @mpw.get_password(item.id)) assert_equal(@fixtures['add_new']['host'], result['host'])
else assert_equal(@fixtures['add_new']['protocol'], result['protocol'])
assert_equal(v, item.send(k).to_s) assert_equal(@fixtures['add_new']['user'], result['user'])
end assert_equal(@fixtures['add_new']['password'], result['password'])
end assert_equal(@fixtures['add_new']['port'].to_i, result['port'])
assert_equal(@fixtures['add_new']['comment'], result['comment'])
@mpw.write_data File.unlink(export_file)
end end
def test_03_decrypt_file def test_03_import_csv
@mpw.read_data import_file = 'files/test_import.csv'
assert_equal(1, @mpw.list.length)
item = @mpw.list[0] assert(@mpw.import(import_file, :csv))
@fixtures['add'].each do |k, v| assert_equal(2, @mpw.list.length)
if k == 'password'
assert_equal(v, @mpw.get_password(item.id))
else
assert_equal(v, item.send(k).to_s)
end
end
end
def test_04_delete_item import = CSV.parse(File.read(import_file), headers: true)
@mpw.read_data
assert_equal(1, @mpw.list.length)
@mpw.list.each(&:delete) item = @mpw.list[0]
assert_equal(0, @mpw.list.length) assert_equal(import[0]['name'], item.name)
assert_equal(import[0]['group'], item.group)
assert_equal(import[0]['host'], item.host)
assert_equal(import[0]['protocol'], item.protocol)
assert_equal(import[0]['user'], item.user)
assert_equal(import[0]['password'], item.password)
assert_equal(import[0]['port'].to_i, item.port)
assert_equal(import[0]['comment'], item.comment)
end
@mpw.write_data def test_04_export_csv
end import_file = 'files/test_import.csv'
export_file = 'test_export.csv'
def test_05_search assert(@mpw.import(import_file, :csv))
@mpw.read_data assert_equal(2, @mpw.list.length)
assert(@mpw.export(export_file, :csv))
export = CSV.parse(File.read(export_file), headers: true)
assert_equal(2, export.length)
@fixtures.each_value do |v| result = export[0]
data = { assert_equal(@fixtures['add_new']['name'], result['name'])
group: v['group'], assert_equal(@fixtures['add_new']['group'], result['group'])
user: v['user'], assert_equal(@fixtures['add_new']['host'], result['host'])
url: v['url'], assert_equal(@fixtures['add_new']['protocol'], result['protocol'])
comment: v['comment'] assert_equal(@fixtures['add_new']['user'], result['user'])
} assert_equal(@fixtures['add_new']['password'], result['password'])
assert_equal(@fixtures['add_new']['port'], result['port'])
assert_equal(@fixtures['add_new']['comment'], result['comment'])
item = MPW::Item.new(data) File.unlink(export_file)
end
assert(!item.nil?) def test_05_add_item
assert(!item.empty?) data = {name: @fixtures['add_new']['name'],
group: @fixtures['add_new']['group'],
host: @fixtures['add_new']['host'],
protocol: @fixtures['add_new']['protocol'],
user: @fixtures['add_new']['user'],
password: @fixtures['add_new']['password'],
port: @fixtures['add_new']['port'],
comment: @fixtures['add_new']['comment'],
}
item = MPW::Item.new(data)
@mpw.add(item) assert(!item.nil?)
@mpw.set_password(item.id, v['password']) assert(!item.empty?)
end
assert_equal(3, @mpw.list.length) assert(@mpw.add(item))
assert_equal(1, @mpw.list(group: @fixtures['add']['group']).length)
assert_equal(1, @mpw.list(pattern: 'gogole').length)
assert_equal(2, @mpw.list(pattern: 'example[2\.]').length)
end
def test_06_add_gpg_key assert_equal(1, @mpw.list.length)
@mpw.read_data
@mpw.add_key('test2@example.com') item = @mpw.list[0]
assert_equal(2, @mpw.list_keys.length) assert_equal(@fixtures['add_new']['name'], item.name)
assert_equal(@fixtures['add_new']['group'], item.group)
assert_equal(@fixtures['add_new']['host'], item.host)
assert_equal(@fixtures['add_new']['protocol'], item.protocol)
assert_equal(@fixtures['add_new']['user'], item.user)
assert_equal(@fixtures['add_new']['password'], item.password)
assert_equal(@fixtures['add_new']['port'].to_i, item.port)
assert_equal(@fixtures['add_new']['comment'], item.comment)
end
@mpw.write_data def test_11_encrypt_empty_file
end assert(@mpw.encrypt)
end
def test_07_delete_gpg_key def test_12_encrypt
@mpw.read_data import_file = 'files/test_import.yml'
assert_equal(2, @mpw.list_keys.length)
@mpw.delete_key('test2@example.com') assert(@mpw.import(import_file, :yaml))
assert_equal(1, @mpw.list_keys.length) assert_equal(2, @mpw.list.length)
@mpw.write_data assert(@mpw.encrypt)
end end
def test_13_decrypt_empty_file
assert(@mpw.decrypt)
assert_equal(0, @mpw.list.length)
end
def test_14_decrypt
import_file = 'files/test_import.yml'
assert(@mpw.import(import_file, :yaml))
assert_equal(2, @mpw.list.length)
assert(@mpw.encrypt)
assert(@mpw.decrypt)
assert_equal(2, @mpw.list.length)
item = @mpw.list[0]
assert_equal(@fixtures['add_new']['name'], item.name)
assert_equal(@fixtures['add_new']['group'], item.group)
assert_equal(@fixtures['add_new']['host'], item.host)
assert_equal(@fixtures['add_new']['protocol'], item.protocol)
assert_equal(@fixtures['add_new']['user'], item.user)
assert_equal(@fixtures['add_new']['password'], item.password)
assert_equal(@fixtures['add_new']['port'].to_i, item.port)
assert_equal(@fixtures['add_new']['comment'], item.comment)
end
def test_15_search
import_file = 'files/test_import.yml'
assert(@mpw.import(import_file, :yaml))
assert_equal(2, @mpw.list.length)
assert_equal(1, @mpw.list(group: @fixtures['add_new']['group']).length)
assert_equal(1, @mpw.list(protocol: @fixtures['add_new']['protocol']).length)
assert_equal(2, @mpw.list(search: @fixtures['add_new']['name'][0..-2]).length)
end
end end

29
test/test_translate.rb
View file

@ -1,29 +0,0 @@
require 'yaml'
require 'test/unit'
class TestTranslate < Test::Unit::TestCase
def test_00_check_translate
missing = 0
Dir.glob('i18n/*.yml').each do |yaml|
lang = File.basename(yaml, '.yml')
translate = YAML.load_file(yaml)
%x(grep -r -o "I18n.t('.*)" bin/ lib/ | cut -d"'" -f2).each_line do |line|
begin
t = translate[lang]
line.strip.split('.').each do |v|
t = t[v]
end
assert(!t.to_s.empty?)
rescue
puts "#{lang}.#{line}"
missing = 1
end
end
end
assert_equal(0, missing)
end
end

4
test/tests.rb Normal file
View file

@ -0,0 +1,4 @@
#!/usr/bin/ruby
require_relative 'test_mpw.rb'
require_relative 'test_item.rb'