moparisthebest/open-keychain
1
0
Fork 0
mirror of https://github.com/moparisthebest/open-keychain synced 2024-11-27 11:12:15 -05:00
Code Issues Releases Wiki Activity

Merge branch 'issue1050' of https://github.com/lezorich/open-keychain into passphrase-strength-indicator

Browse Source 
Conflicts:
	OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateKeyInputFragment.java
This commit is contained in:
Dominik Schürmann 2015-03-05 23:29:43 +01:00
commit 23b8e8272c
6 changed files with 536 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpConstants.java
View File

@ -29,6 +29,8 @@ public class PgpConstants {
public static ArrayList<Integer> sPreferredHashAlgorithms = new ArrayList<>();
public static ArrayList<Integer> sPreferredCompressionAlgorithms = new ArrayList<>();
// TODO: use hashmaps for contains in O(1) and intersections!
/*
* Most preferred is first
* These arrays are written as preferred algorithms into the keys on creation.

26
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateKeyInputFragment.java
View File

@ -33,6 +33,7 @@ import android.widget.EditText;
import org.sufficientlysecure.keychain.R;
import org.sufficientlysecure.keychain.ui.CreateKeyActivity.FragAction;
import org.sufficientlysecure.keychain.ui.widget.passwordstrengthindicator.PasswordStrengthView;
import org.sufficientlysecure.keychain.util.ContactHelper;
import java.util.regex.Matcher;
@ -41,6 +42,7 @@ public class CreateKeyInputFragment extends Fragment {
CreateKeyActivity mCreateKeyActivity;
PasswordStrengthView mPassphraseStrengthView;
AutoCompleteTextView mNameEdit;
AutoCompleteTextView mEmailEdit;
EditText mPassphraseEdit;
@ -69,6 +71,8 @@ public class CreateKeyInputFragment extends Fragment {
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
View view = inflater.inflate(R.layout.create_key_input_fragment, container, false);
mPassphraseStrengthView = (PasswordStrengthView) view.findViewById(R.id
.create_key_passphrase_strength);
mNameEdit = (AutoCompleteTextView) view.findViewById(R.id.create_key_name);
mEmailEdit = (AutoCompleteTextView) view.findViewById(R.id.create_key_email);
mPassphraseEdit = (EditText) view.findViewById(R.id.create_key_passphrase);
@ -131,6 +135,28 @@ public class CreateKeyInputFragment extends Fragment {
)
);
// Edit text padding doesn't work via xml (http://code.google.com/p/android/issues/detail?id=77982)
// so we set the right padding programmatically.
mPassphraseEdit.setPadding(mPassphraseEdit.getPaddingLeft(),
mPassphraseEdit.getPaddingTop(),
(int) (56 * getResources().getDisplayMetrics().density),
mPassphraseEdit.getPaddingBottom());
mPassphraseEdit.addTextChangedListener(new TextWatcher() {
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
}
@Override
public void afterTextChanged(Editable editable) {
String passphrase = editable.toString();
mPassphraseStrengthView.setPassword(passphrase);
}
});
mCreateButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {

118
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/widget/passwordstrengthindicator/PasswordStrengthBarView.java Normal file
View File

@ -0,0 +1,118 @@
/*
* The MIT License (MIT)
*
* Copyright (c) 2014 Matt Allen
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.sufficientlysecure.keychain.ui.widget.passwordstrengthindicator;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.util.AttributeSet;
/**
* Created by matt on 04/07/2014.
* https://github.com/matt-allen/android-password-strength-indicator
*
*/
public class PasswordStrengthBarView extends PasswordStrengthView {
public PasswordStrengthBarView(Context context, AttributeSet attrs) {
super(context, attrs);
mMinHeight = 80;
mMinWidth = 300;
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
generateIndicatorColor();
// Default to full width
int indWidth = mIndicatorWidth;
// If score, leave it as full - can cause it to become
// less than full width in this calculation
if (mCurrentScore < 20) indWidth = (mIndicatorWidth / 20) * mCurrentScore;
// Draw indicator
canvas.drawRect(
getPaddingLeft(),
getPaddingTop(),
indWidth,
mIndicatorHeight,
mIndicatorPaint
);
// Draw guides if true
if (mShowGuides) {
// TODO: Try and do this with a loop, for efficiency
// Draw bottom guide border
float positionY = getHeight()-getPaddingBottom()-getPaddingTop();
float notchHeight = (float)(positionY * 0.8);
canvas.drawLine(
getPaddingLeft(),
positionY,
getWidth()-getPaddingRight(),
positionY,
mGuidePaint);
// Show left-most notch
canvas.drawLine(
getPaddingLeft(),
positionY,
getPaddingLeft(),
notchHeight,
mGuidePaint
);
// Show middle-left notch
canvas.drawLine(
(float)(mIndicatorWidth*0.25)+getPaddingLeft(),
positionY,
(float)(mIndicatorWidth*0.25)+getPaddingLeft(),
notchHeight,
mGuidePaint
);
// Show the middle notch
canvas.drawLine(
(float)(mIndicatorWidth*0.5)+getPaddingLeft(),
positionY,
(float)(mIndicatorWidth*0.5)+getPaddingLeft(),
notchHeight,
mGuidePaint
);
// Show the middle-right notch
canvas.drawLine(
(float)(mIndicatorWidth*0.75)+getPaddingLeft(),
positionY,
(float)(mIndicatorWidth*0.75)+getPaddingLeft(),
notchHeight,
mGuidePaint
);
// Show the right-most notch
canvas.drawLine(
mIndicatorWidth+getPaddingLeft(),
positionY,
mIndicatorWidth+getPaddingLeft(),
notchHeight,
mGuidePaint
);
}
}
}

350
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/widget/passwordstrengthindicator/PasswordStrengthView.java Normal file
View File

@ -0,0 +1,350 @@
/*
* The MIT License (MIT)
*
* Copyright (c) 2014 Matt Allen
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package org.sufficientlysecure.keychain.ui.widget.passwordstrengthindicator;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Color;
import android.graphics.Paint;
import android.util.AttributeSet;
import android.view.View;
import org.sufficientlysecure.keychain.R;
/**
* Created by Matt Allen
* 01/07/14
* http://www.mattallensoftware.co.uk
* mattallen092@gmail.com
*
* https://github.com/matt-allen/android-password-strength-indicator
*
* <p>
* This View is designed to indicate how secure a user-entered password is in a visual way to
* relay to the user if they need to make it stronger. The strength of the password can be set
* at creation (or after) which will decide whether their password is strong enough.
* </p>
*
* <p>
* The password strength is decided by an index of 20. The minimum score needed to pass is 10
* which means the String has met the conditions imposed by the strength test, but can be improved.
* If the password scores 10-19 it is considered weak, and only if it scores 20 will it be
* considered strong.
* </p>
*/
public class PasswordStrengthView extends View {
protected static final int COLOR_FAIL = Color.parseColor("#e74c3c");
protected static final int COLOR_WEAK = Color.parseColor("#e67e22");
protected static final int COLOR_STRONG = Color.parseColor("#2ecc71");
protected int mMinWidth;
protected int mMinHeight;
protected Paint mIndicatorPaint;
protected Paint mGuidePaint;
protected int mIndicatorHeight;
protected int mIndicatorWidth;
protected int mCurrentScore;
protected int mColorFail;
protected int mColorWeak;
protected int mColorStrong;
protected boolean mShowGuides = true;
/**
* Used to define that the indicator should only be looking
* for a weak password. The bare minimum is used here to let
* the user continue.
*/
public static final int STRENGTH_WEAK = 0;
/**
* A fairly strict rule for generating a password. It encourages a password that is
* less easy to crack.
*/
public static final int STRENGTH_MEDIUM = 1;
/**
* A strong algorithm that encourages very strong passwords that should be fairly long, with
* non-alphanumeric, numbers, and upper case.
*/
public static final int STRENGTH_STRONG = 2;
private int mStrengthRequirement = -1;
protected String mPassword;
public PasswordStrengthView(Context context, AttributeSet attrs) {
super(context, attrs);
TypedArray style = context.getTheme().obtainStyledAttributes(
attrs,
R.styleable.PasswordStrengthView,
0, 0);
try {
mStrengthRequirement = style.getInteger(R.styleable.PasswordStrengthView_strength,
STRENGTH_MEDIUM);
mShowGuides = style.getBoolean(R.styleable.PasswordStrengthView_showGuides, true);
mColorFail = style.getColor(R.styleable.PasswordStrengthView_color_fail, COLOR_FAIL);
mColorWeak = style.getColor(R.styleable.PasswordStrengthView_color_weak, COLOR_WEAK);
mColorStrong = style.getColor(R.styleable.PasswordStrengthView_color_strong,
COLOR_STRONG);
} catch (Exception e){
e.printStackTrace();
}
// Create and style the paint used for drawing the guide on the indicator
mGuidePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
mGuidePaint.setStyle(Paint.Style.FILL_AND_STROKE);
mGuidePaint.setColor(Color.BLACK);
// Create and style paint for indicator
mIndicatorPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
mIndicatorPaint.setStyle(Paint.Style.FILL);
}
/**
* This view can determine if the password entered by the user is acceptable for
* use by your use case. This is based on the strength requirement you have set.
* @return True if requirement has been met
*/
public boolean isStrengthRequirementMet() {
return (mCurrentScore >= 10);
}
/**
* Change the strength requirement of the password entered by the user. This will also
* re-check the password already entered against these new requirements.
* @param requiredStrength Use the public constants of this class to set
*/
public void setStrengthRequirement(int requiredStrength) {
if(requiredStrength >= 0 && requiredStrength <= 2){
mStrengthRequirement = requiredStrength;
if (mPassword != null && mPassword.length() > 0) {
generatePasswordScore();
// Update view with new score
invalidate();
requestLayout();
}
} else {
throw new IndexOutOfBoundsException("Input out of expected range");
}
}
/**
* Update the password string to check strength of
* @param passwordString String representation of user-input
*/
public void setPassword(String passwordString) {
if(passwordString != null && passwordString.length() > 0) {
mPassword = passwordString;
generatePasswordScore();
} else {
mPassword = "";
mCurrentScore = 0;
}
// Update view with new score
invalidate();
requestLayout();
}
/**
* Private convenience method for adding to the password score
* @param score Amount to be added to current score
*/
protected void addToPasswordScore(int score) {
int newScore = mCurrentScore + score;
// Limit max score
if (newScore > 20){
mCurrentScore = 20;
} else {
mCurrentScore = newScore;
}
}
/**
* Call this to determine the current strength requirement set on the algorithm
* @return Int representation of the current strength set for the indicator
*/
public int getStrengthRequirement() {
return mStrengthRequirement;
}
/**
* Generate a score based on the password. The password will already need to be stored
* as a class member before running this.
*/
protected void generatePasswordScore() {
mCurrentScore = 0;
int upperCase = getUppercaseCount(mPassword);
int nonAlpha = getNonAlphanumericCount(mPassword);
int numbers = getNumberCount(mPassword);
switch (mStrengthRequirement){
case STRENGTH_WEAK:
addToPasswordScore(mPassword.length()*2);
addToPasswordScore(upperCase*2);
addToPasswordScore(nonAlpha*2);
addToPasswordScore(numbers*2);
break;
case STRENGTH_MEDIUM:
addToPasswordScore(mPassword.length());
addToPasswordScore(upperCase);
addToPasswordScore(nonAlpha*2);
addToPasswordScore(numbers);
break;
case STRENGTH_STRONG:
addToPasswordScore(mPassword.length()/2);
// Cut the score in half to make this a very high requirement
addToPasswordScore(upperCase);
addToPasswordScore(nonAlpha);
addToPasswordScore(numbers);
break;
}
}
@Override
protected void onSizeChanged(int w, int h, int oldW, int oldH) {
super.onSizeChanged(w, h, oldW, oldH);
int paddingX = getPaddingLeft();
int paddingY = getPaddingTop();
mIndicatorHeight = h - paddingY;
mIndicatorWidth = w - paddingX;
}
/**
* The standard parts of the onMeasure needed to create the password strength
* indicator. Subclasses should call super.onMeasure, but also need to set
* the minimum height and width in the constructor.
* @param widthMeasureSpec The measurement given by the system
* @param heightMeasureSpec The measurement given by the system
*/
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
// Set minimum space for the view to do it's thing
int minW = getPaddingLeft() + getPaddingRight() + mMinWidth;
int w = resolveSizeAndState(minW, widthMeasureSpec, 1);
// And give it enough height so it's visible
int minH = mMinHeight + getPaddingBottom() + getPaddingTop();
int h = resolveSizeAndState(minH, heightMeasureSpec, 0);
// Feed these back into UIKit
setMeasuredDimension(w, h);
}
/**
* Set the colour of the indicator {@code Paint} to one that is appropriate
* for the strength of the password.
*/
protected void generateIndicatorColor() {
int color = mColorFail;
if (mCurrentScore >= 18) {
color = mColorStrong;
}
else if (mCurrentScore >= 10) {
color = mColorWeak;
}
mIndicatorPaint.setColor(color);
}
/**
* Quick method to determine how many of the characters in a given string are upper case
* @param stringToCheck The string to examine
* @return Number of upper case characters
*/
protected int getUppercaseCount(String stringToCheck) {
int score = 0;
int loops = stringToCheck.length()-1;
for (int i=0;i<=loops;i++){
if(Character.isUpperCase(stringToCheck.charAt(i))) {
score++;
}
}
return score;
}
/**
* A convenience method to determine how many characters in the given String aren't
* letters or numbers.
* @param stringToCheck
* @return Number of characters that aren't numbers or letters
*/
protected int getNonAlphanumericCount(String stringToCheck) {
int score = 0;
int loops = stringToCheck.length()-1;
for (int i=0;i<=loops;i++) {
if(!Character.isLetter(stringToCheck.charAt(i)) &&
!Character.isDigit(stringToCheck.charAt(i))){
score++;
}
}
return score;
}
/**
* A convenience method for returning the count of numbers in a given String.
* @param stringToCheck
* @return The numbers of digits in the String
*/
protected int getNumberCount(String stringToCheck) {
int score = 0;
int loops = stringToCheck.length()-1;
for (int i=0;i<=loops;i++) {
if(Character.isDigit(stringToCheck.charAt(i))) {
score++;
}
}
return score;
}
/**
* Set the guides to show on the view.<br />
* On the line style, the guides will show underneath<br />
* On the rounded style, the guides will be shown on the outer edges.<br />
* The view will be redrawn after the method is called.
* @param showGuides True if you want the guides to be shown
*/
public void setShowGuides(boolean showGuides) {
mShowGuides = showGuides;
if (mPassword != null && mPassword.length() > 0) {
generatePasswordScore();
} else {
mCurrentScore = 0;
}
invalidate();
requestLayout();
}
/**
* Determine whether the view is showing the guides for the password score
* @return True if the guides are being shown
*/
public boolean isShowingGuides() {
return mShowGuides;
}
}

22
OpenKeychain/src/main/res/layout/create_key_input_fragment.xml
View File

@ -1,5 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:custom="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent">
@ -58,18 +59,35 @@
android:layout_height="wrap_content"
android:text="@string/label_passphrase" />
<FrameLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginTop="8dp"
android:layout_marginBottom="8dp">
<EditText
android:id="@+id/create_key_passphrase"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginTop="8dp"
android:layout_marginBottom="8dp"
android:imeOptions="actionNext"
android:inputType="textPassword"
android:hint="@string/label_passphrase"
android:ems="10"
android:layout_gravity="center_horizontal" />
<org.sufficientlysecure.keychain.ui.widget.passwordstrengthindicator.PasswordStrengthBarView
android:id="@+id/create_key_passphrase_strength"
android:layout_width="48dp"
android:layout_height="8dp"
android:layout_gravity="end|center_vertical"
custom:strength="medium"
custom:showGuides="false"
custom:color_fail="@color/android_red_light"
custom:color_weak="@color/android_orange_light"
custom:color_strong="@color/android_green_light"/>
</FrameLayout>
<EditText
android:id="@+id/create_key_passphrase_again"
android:layout_width="match_parent"

14
OpenKeychain/src/main/res/values/attr.xml
View File

@ -15,4 +15,18 @@
</attr>
</declare-styleable>
<!-- Taken from Matt Allen Password Strength View
https://github.com/matt-allen/android-password-strength-indicator -->
<declare-styleable name="PasswordStrengthView">
<attr name="strength" format="enum">
<enum name="weak" value="0" />
<enum name="medium" value="1" />
<enum name="strong" value="2" />
</attr>
<attr name="showGuides" format="boolean" />
<attr name="color_fail" format="color" />
<attr name="color_weak" format="color" />
<attr name="color_strong" format="color" />
</declare-styleable>
</resources>