public override string GetString(int column)
{
try
{
if ((Position >= _entriesWithContexts.Count) || (Position < 0))
{
return("");
}
switch (column)
{
case 0: // _ID
return(Position.ToString(CultureInfo.InvariantCulture));
case 1: // SuggestColumnText1
return(CurrentEntry.Strings.ReadSafe(PwDefs.TitleField));
case 2: // SuggestColumnText2
return(Internationalise(_entriesWithContexts[Position].resultContext));
case 3: // SuggestColumnIcon1
var builder = new Android.Net.Uri.Builder();
builder.Scheme(ContentResolver.SchemeContent);
builder.Authority(Authority);
builder.Path(GetIconPathQuery);
builder.AppendQueryParameter(IconIdParameter, CurrentEntry.IconId.ToString());
builder.AppendQueryParameter(CustomIconUuidParameter, CurrentEntry.CustomIconUuid.ToHexString());
builder.AppendQueryParameter(DatabaseIndexParameter, _entriesWithContexts[Position].DatabaseIndex.ToString());
return(builder.Build().ToString());
case 4: // SuggestColumnIntentDataId
return(new ElementAndDatabaseId(App.Kp2a.FindDatabaseForElement(CurrentEntry), CurrentEntry).FullId);
default:
return(null);
}
}
catch (Exception e)
{
Kp2aLog.LogUnexpectedError(e);
return("(error retrieving data)");
}
}
private DateTime ReadTime(XmlReader xr)
{
// Cf. WriteObject(string, DateTime)
if ((m_format == KdbxFormat.Default) && (m_uFileVersion >= FileVersion32_4))
{
// long l = ReadLong(xr, -1);
// if(l != -1) return DateTime.FromBinary(l);
string str = ReadString(xr);
byte[] pb = Convert.FromBase64String(str);
if (pb.Length != 8)
{
Debug.Assert(false);
byte[] pb8 = new byte[8];
Array.Copy(pb, pb8, Math.Min(pb.Length, 8)); // Little-endian
pb = pb8;
}
long lSec = MemUtil.BytesToInt64(pb);
try
{
return(new DateTime(lSec * TimeSpan.TicksPerSecond, DateTimeKind.Utc));
}
catch (System.ArgumentOutOfRangeException e)
{
//files might contain bad data, e.g. see #868. Fall back to MinValue
Kp2aLog.Log("Failed to read date from file.");
return(DateTime.MinValue);
}
}
else
{
string str = ReadString(xr);
DateTime dt;
if (TimeUtil.TryDeserializeUtc(str, out dt))
{
return(dt);
}
}
Debug.Assert(false);
return(m_dtNow);
}
private void Query(SearchParameters searchParams)
{
try {
Group = App.Kp2a.GetDb().Search(searchParams, null);
} catch (Exception e) {
Kp2aLog.LogUnexpectedError(e);
Toast.MakeText(this, e.Message, ToastLength.Long).Show();
Finish();
return;
}
if (Group == null || (!Group.Entries.Any()))
{
SetContentView(Resource.Layout.group_empty);
}
SetGroupTitle();
FragmentManager.FindFragmentById <GroupListFragment>(Resource.Id.list_fragment).ListAdapter = new PwGroupListAdapter(this, Group);
}
public static bool TryTakePersistablePermissions(ContentResolver contentResolver, Android.Net.Uri uri)
{
if ((int)Build.VERSION.SdkInt >= 19)
{
//try to take persistable permissions
try
{
Kp2aLog.Log("TakePersistableUriPermission");
var takeFlags = (ActivityFlags.GrantReadUriPermission
| ActivityFlags.GrantWriteUriPermission);
contentResolver.TakePersistableUriPermission(uri, takeFlags);
return(true);
}
catch (Exception e)
{
Kp2aLog.Log(e.ToString());
}
}
return(false);
}
public static Uri IocToUri(IOConnectionInfo ioc)
{
if (!string.IsNullOrEmpty(ioc.UserName))
{
//legacy support.
return(new Uri(ioc.Path));
}
string path = ioc.Path;
//remove additional stuff like TLS param
int schemeLength = path.IndexOf("://", StringComparison.Ordinal);
string scheme = path.Substring(0, schemeLength);
path = path.Substring(schemeLength + 3);
if (path.StartsWith(ConnectionSettings.SettingsPrefix))
{
//this should always be the case. However, in rare cases we might get an ioc with legacy path but no username set (if they only want to get a display name)
string settings = path.Substring(0, path.IndexOf(ConnectionSettings.SettingsPostFix, StringComparison.Ordinal));
path = path.Substring(settings.Length + 1);
}
Kp2aLog.Log("FTP: IocToUri out = " + scheme + "://" + path);
return(new Uri(scheme + "://" + path));
}
protected override void OnPreExecute()
{
new Handler().PostDelayed(() =>
{
if (!mFinished)
{
try
{
/*
* sometime the activity has been finished before we
* show this dialog, it will raise error
*/
mDialog.Show();
}
catch (Exception t)
{
Kp2aLog.LogUnexpectedError(t);
}
}
}
, mDelayTime);
}
/// <summary>
/// Wraps autofill data in a LoginCredential Dataset object which can then be sent back to the
/// client View.
/// </summary>
/// <returns>The dataset.</returns>
/// <param name="context">Context.</param>
/// <param name="autofillFields">Autofill fields.</param>
/// <param name="filledAutofillFieldCollection">Filled autofill field collection.</param>
public static Dataset NewDataset(Context context,
AutofillFieldMetadataCollection autofillFields, FilledAutofillFieldCollection filledAutofillFieldCollection, IAutofillIntentBuilder intentBuilder)
{
var datasetName = filledAutofillFieldCollection.DatasetName ?? "[noname]";
var datasetBuilder = new Dataset.Builder(NewRemoteViews(context.PackageName, datasetName, intentBuilder.AppIconResource));
datasetBuilder.SetId(datasetName);
var setValueAtLeastOnce = filledAutofillFieldCollection.ApplyToFields(autofillFields, datasetBuilder);
if (setValueAtLeastOnce)
{
return(datasetBuilder.Build());
}
else
{
Kp2aLog.Log("Failed to set at least one value. #fields=" + autofillFields.GetAutofillIds().Length + " " + autofillFields.FocusedAutofillCanonicalHints);
}
return(null);
}
public bool IsReadOnly(IOConnectionInfo ioc, OptionalOut <UiStringKey> reason = null)
{
ICursor cursor = null;
try
{
//on pre-Kitkat devices, we can't write content:// files
if (!IsKitKatOrLater)
{
Kp2aLog.Log("File is read-only because we're not on KitKat or later.");
if (reason != null)
{
reason.Result = UiStringKey.ReadOnlyReason_PreKitKat;
}
return(true);
}
//in previous implementations, we were checking for FLAG_SUPPORTS_WRITE in the document flags,
//but it seems like this is very poorly supported, e.g. Dropbox and OneDrive return !FLAG_SUPPORTS_WRITE
//even though writing work.
return(false);
}
catch (Exception e)
{
Kp2aLog.LogUnexpectedError(e);
//better return false here. We don't really know what happened (as this is unexpected).
//let the user try to write the file. If it fails they will get an exception string.
return(false);
}
finally
{
if (cursor != null)
{
cursor.Close();
}
}
}
public override Android.Database.ICursor Query(Android.Net.Uri uri, string[] projection, string selection, string[] selectionArgs, string sortOrder)
{
if (App.Kp2a.DatabaseIsUnlocked) // Can't show suggestions if the database is locked!
{
switch ((UriMatches)UriMatcher.Match(uri))
{
case UriMatches.GetSuggestions:
var searchString = selectionArgs[0];
if (!String.IsNullOrEmpty(searchString))
{
try
{
var resultsContexts = new Dictionary <PwUuid, KeyValuePair <string, string> >();
var result = _db.Search(new SearchParameters {
SearchString = searchString
}, resultsContexts);
return(new GroupCursor(result, resultsContexts));
}
catch (Exception e)
{
Kp2aLog.LogUnexpectedError(new Exception("Failed to search for suggestions", e));
}
}
break;
case UriMatches.GetIcon:
return(null); // This will be handled by OpenAssetFile
default:
return(null);
//throw new ArgumentException("Unknown Uri: " + uri, "uri");
}
}
return(null);
}
public static byte[] ReadFile(IOConnectionInfo ioc)
{
Stream sIn = null;
MemoryStream ms = null;
try
{
sIn = IOConnection.OpenRead(ioc);
if (sIn == null)
{
return(null);
}
ms = new MemoryStream();
MemUtil.CopyStream(sIn, ms);
return(ms.ToArray());
}
catch (Exception e)
{
Kp2aLog.Log("error opening file: " + e);
}
finally
{
if (sIn != null)
{
sIn.Close();
}
if (ms != null)
{
ms.Close();
}
}
return(null);
}
private static byte[] GetOtpSecret(IDictionary <string, string> entryFields, string strPrefix)
{
try
{
string str;
entryFields.TryGetValue(strPrefix + "Secret", out str);
if (!string.IsNullOrEmpty(str))
{
return(StrUtil.Utf8.GetBytes(str));
}
entryFields.TryGetValue(strPrefix + "Secret-Hex", out str);
if (!string.IsNullOrEmpty(str))
{
return(MemUtil.HexStringToByteArray(str));
}
entryFields.TryGetValue(strPrefix + "Secret-Base32", out str);
if (!string.IsNullOrEmpty(str))
{
return(MemUtil.ParseBase32(str));
}
entryFields.TryGetValue(strPrefix + "Secret-Base64", out str);
if (!string.IsNullOrEmpty(str))
{
return(Convert.FromBase64String(str));
}
}
catch (Exception e)
{
Kp2aLog.LogUnexpectedError(e);
}
return(null);
}
protected override void OnCreate(Bundle savedInstanceState)
{
Kp2aLog.Log("ChooseForAutofillActivityBase.OnCreate");
base.OnCreate(savedInstanceState);
//if launched from history, don't re-use the task. Proceed to FileSelect instead.
if (Intent.Flags.HasFlag(ActivityFlags.LaunchedFromHistory))
{
Kp2aLog.Log("ChooseForAutofillActivityBase: started from history");
Kp2aLog.Log("Forwarding to FileSelect. QueryCredentialsActivity started from history.");
RestartApp();
return;
}
string requestedUrl = Intent.GetStringExtra(ExtraQueryString);
if (requestedUrl == null)
{
Kp2aLog.Log("ChooseForAutofillActivityBase: no requestedUrl ");
Toast.MakeText(this, "Cannot execute query for null.", ToastLength.Long).Show();
RestartApp();
return;
}
if (Intent.HasExtra(ExtraDisplayWarning))
{
AutofillServiceBase.DisplayWarning warning =
(AutofillServiceBase.DisplayWarning)Intent.GetIntExtra(ExtraDisplayWarning, (int)AutofillServiceBase.DisplayWarning.None);
Kp2aLog.Log("ChooseForAutofillActivityBase: ExtraDisplayWarning = " + warning);
if (warning != AutofillServiceBase.DisplayWarning.None)
{
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.SetTitle(this.GetString(Resource.String.AutofillWarning_title));
string appName = Intent.GetStringExtra(ExtraQueryPackageString);
string appNameWithPackage = appName;
try
{
var appInfo = PackageManager.GetApplicationInfo(appName, 0);
if (appInfo != null)
{
appName = PackageManager.GetApplicationLabel(appInfo);
appNameWithPackage = appName + " (" + Intent.GetStringExtra(ExtraQueryPackageString) + ")";
}
}
catch (Exception)
{
// ignored
}
builder.SetMessage(
GetString(Resource.String.AutofillWarning_Intro, new Java.Lang.Object[]
{
Intent.GetStringExtra(ExtraQueryDomainString), appNameWithPackage
})
+ " " +
this.GetString(Resource.String.AutofillWarning_FillDomainInUntrustedApp, new Java.Lang.Object[]
{
Intent.GetStringExtra(ExtraQueryDomainString), appName
}));
builder.SetPositiveButton(this.GetString(Resource.String.Continue),
(dlgSender, dlgEvt) =>
{
new Kp2aDigitalAssetLinksDataSource(this).RememberTrustedLink(Intent.GetStringExtra(ExtraQueryDomainString),
Intent.GetStringExtra(ExtraQueryPackageString));
Proceed();
});
builder.SetNeutralButton(this.GetString(Resource.String.AutofillWarning_trustAsBrowser, new Java.Lang.Object[]
{ appName }),
(sender, args) =>
{
new Kp2aDigitalAssetLinksDataSource(this).RememberAsTrustedApp(Intent.GetStringExtra(ExtraQueryPackageString));
Proceed();
});
builder.SetNegativeButton(this.GetString(Resource.String.cancel), (dlgSender, dlgEvt) =>
{
Finish();
});
Dialog dialog = builder.Create();
dialog.Show();
return;
}
}
else
{
Kp2aLog.Log("ChooseForAutofillActivityBase: No ExtraDisplayWarning");
}
Proceed();
}
/// <summary>
/// Load a KDBX file from a stream.
/// </summary>
/// <param name="sSource">Stream to read the data from. Must contain
/// a KDBX stream.</param>
/// <param name="fmt">Format.</param>
/// <param name="slLogger">Status logger (optional).</param>
public void Load(Stream sSource, KdbxFormat fmt, IStatusLogger slLogger)
{
Debug.Assert(sSource != null);
if (sSource == null)
{
throw new ArgumentNullException("sSource");
}
if (m_bUsedOnce)
{
throw new InvalidOperationException("Do not reuse KdbxFile objects!");
}
m_bUsedOnce = true;
#if KDBX_BENCHMARK
Stopwatch swTime = Stopwatch.StartNew();
#endif
m_format = fmt;
m_slLogger = slLogger;
m_pbsBinaries.Clear();
UTF8Encoding encNoBom = StrUtil.Utf8;
byte[] pbCipherKey = null;
byte[] pbHmacKey64 = null;
List <Stream> lStreams = new List <Stream>();
lStreams.Add(sSource);
HashingStreamEx sHashing = new HashingStreamEx(sSource, false, null);
lStreams.Add(sHashing);
try
{
Stream sXml;
if (fmt == KdbxFormat.Default || fmt == KdbxFormat.ProtocolBuffers)
{
BinaryReaderEx br = new BinaryReaderEx(sHashing,
encNoBom, KLRes.FileCorrupted);
byte[] pbHeader = LoadHeader(br);
m_pbHashOfHeader = CryptoUtil.HashSha256(pbHeader);
int cbEncKey, cbEncIV;
ICipherEngine iCipher = GetCipher(out cbEncKey, out cbEncIV);
if (m_slLogger != null)
{
m_slLogger.SetText("KP2AKEY_TransformingKey", LogStatusType.AdditionalInfo);
}
ComputeKeys(out pbCipherKey, cbEncKey, out pbHmacKey64);
string strIncomplete = KLRes.FileHeaderCorrupted + " " +
KLRes.FileIncomplete;
Stream sPlain;
if (m_uFileVersion < FileVersion32_4)
{
Stream sDecrypted = EncryptStream(sHashing, iCipher,
pbCipherKey, cbEncIV, false);
if ((sDecrypted == null) || (sDecrypted == sHashing))
{
throw new SecurityException(KLRes.CryptoStreamFailed);
}
if (m_slLogger != null)
{
m_slLogger.SetText("KP2AKEY_DecodingDatabase", LogStatusType.AdditionalInfo);
}
lStreams.Add(sDecrypted);
BinaryReaderEx brDecrypted = new BinaryReaderEx(sDecrypted,
encNoBom, strIncomplete);
byte[] pbStoredStartBytes = brDecrypted.ReadBytes(32);
if ((m_pbStreamStartBytes == null) || (m_pbStreamStartBytes.Length != 32))
{
throw new EndOfStreamException(strIncomplete);
}
if (!MemUtil.ArraysEqual(pbStoredStartBytes, m_pbStreamStartBytes))
{
throw new InvalidCompositeKeyException();
}
if (m_slLogger != null)
{
m_slLogger.SetText("KP2AKEY_DecodingDatabase", LogStatusType.AdditionalInfo);
}
sPlain = new HashedBlockStream(sDecrypted, false, 0, !m_bRepairMode);
}
else // KDBX >= 4
{
byte[] pbStoredHash = MemUtil.Read(sHashing, 32);
if ((pbStoredHash == null) || (pbStoredHash.Length != 32))
{
throw new EndOfStreamException(strIncomplete);
}
if (!MemUtil.ArraysEqual(m_pbHashOfHeader, pbStoredHash))
{
throw new InvalidDataException(KLRes.FileHeaderCorrupted);
}
byte[] pbHeaderHmac = ComputeHeaderHmac(pbHeader, pbHmacKey64);
byte[] pbStoredHmac = MemUtil.Read(sHashing, 32);
if ((pbStoredHmac == null) || (pbStoredHmac.Length != 32))
{
throw new EndOfStreamException(strIncomplete);
}
if (!MemUtil.ArraysEqual(pbHeaderHmac, pbStoredHmac))
{
throw new InvalidCompositeKeyException();
}
HmacBlockStream sBlocks = new HmacBlockStream(sHashing,
false, !m_bRepairMode, pbHmacKey64);
lStreams.Add(sBlocks);
sPlain = EncryptStream(sBlocks, iCipher, pbCipherKey,
cbEncIV, false);
if ((sPlain == null) || (sPlain == sBlocks))
{
throw new SecurityException(KLRes.CryptoStreamFailed);
}
}
lStreams.Add(sPlain);
if (m_pwDatabase.Compression == PwCompressionAlgorithm.GZip)
{
sXml = new GZipStream(sPlain, CompressionMode.Decompress);
lStreams.Add(sXml);
}
else
{
sXml = sPlain;
}
if (m_uFileVersion >= FileVersion32_4)
{
LoadInnerHeader(sXml); // Binary header before XML
}
}
else if (fmt == KdbxFormat.PlainXml)
{
sXml = sHashing;
}
else
{
Debug.Assert(false); throw new ArgumentOutOfRangeException("fmt");
}
if (fmt == KdbxFormat.Default)
{
if (m_pbInnerRandomStreamKey == null)
{
Debug.Assert(false);
throw new SecurityException("Invalid inner random stream key!");
}
m_randomStream = new CryptoRandomStream(m_craInnerRandomStream,
m_pbInnerRandomStreamKey);
}
if (m_slLogger != null)
{
m_slLogger.SetText("KP2AKEY_ParsingDatabase", LogStatusType.AdditionalInfo);
}
#if KeePassDebug_WriteXml
// FileStream fsOut = new FileStream("Raw.xml", FileMode.Create,
// FileAccess.Write, FileShare.None);
// try
// {
// while(true)
// {
// int b = sXml.ReadByte();
// if(b == -1) break;
// fsOut.WriteByte((byte)b);
// }
// }
// catch(Exception) { }
// fsOut.Close();
#endif
var stopWatch = Stopwatch.StartNew();
if (fmt == KdbxFormat.ProtocolBuffers)
{
KdbpFile.ReadDocument(m_pwDatabase, sXml, m_pbInnerRandomStreamKey, m_pbHashOfHeader);
Kp2aLog.Log(String.Format("KdbpFile.ReadDocument: {0}ms", stopWatch.ElapsedMilliseconds));
}
else
{
ReadXmlStreamed(sXml, sHashing);
Kp2aLog.Log(String.Format("ReadXmlStreamed: {0}ms", stopWatch.ElapsedMilliseconds));
}
// ReadXmlDom(sXml);
}
catch (CryptographicException) // Thrown on invalid padding
{
throw new CryptographicException(KLRes.FileCorrupted);
}
finally
{
if (pbCipherKey != null)
{
MemUtil.ZeroByteArray(pbCipherKey);
}
if (pbHmacKey64 != null)
{
MemUtil.ZeroByteArray(pbHmacKey64);
}
CommonCleanUpRead(lStreams, sHashing);
}
#if KDBX_BENCHMARK
swTime.Stop();
MessageService.ShowInfo("Loading KDBX took " +
swTime.ElapsedMilliseconds.ToString() + " ms.");
#endif
}
public bool IsReadOnly(IOConnectionInfo ioc, OptionalOut <UiStringKey> reason = null)
{
ICursor cursor = null;
try
{
//on pre-Kitkat devices, we can't write content:// files
if (!IsKitKatOrLater)
{
Kp2aLog.Log("File is read-only because we're not on KitKat or later.");
if (reason != null)
{
reason.Result = UiStringKey.ReadOnlyReason_PreKitKat;
}
return(true);
}
//KitKat or later...
var uri = Android.Net.Uri.Parse(ioc.Path);
cursor = _ctx.ContentResolver.Query(uri, null, null, null, null, null);
if (cursor != null && cursor.MoveToFirst())
{
int column = cursor.GetColumnIndex(DocumentsContract.Document.ColumnFlags);
if (column < 0)
{
return(false); //seems like this is not supported. See below for reasoning to return false.
}
int flags = cursor.GetInt(column);
Kp2aLog.Log("File flags: " + flags);
if ((flags & (long)DocumentContractFlags.SupportsWrite) == 0)
{
if (reason != null)
{
reason.Result = UiStringKey.ReadOnlyReason_ReadOnlyFlag;
}
return(true);
}
else
{
return(false);
}
}
else
{
throw new Exception("couldn't move to first result element: " + (cursor == null) + uri.ToString());
}
}
catch (Exception e)
{
Kp2aLog.LogUnexpectedError(e);
//better return false here. We don't really know what happened (as this is unexpected).
//let the user try to write the file. If it fails they will get an exception string.
return(false);
}
finally
{
if (cursor != null)
{
cursor.Close();
}
}
}
public void OnResume(IFileStorageSetupActivity activity)
{
Kp2aLog.Log("JFS/OnResume Ioc.Path=" + activity.Ioc.Path + ". Path=" + ((IJavaFileStorageFileStorageSetupActivity)activity).Path);
_jfs.OnResume(((IJavaFileStorageFileStorageSetupActivity)activity));
}
public virtual void StartSelectFile(IFileStorageSetupInitiatorActivity activity, bool isForSave, int requestCode, string protocolId)
{
Kp2aLog.Log("StartSelectFile " + protocolId);
_jfs.StartSelectFile((IJavaFileStorageFileStorageSetupInitiatorActivity)activity, isForSave, requestCode);
}
private List <Dataset> BuildEntryDatasets(string query, string queryDomain, string queryPackage, AutofillId[] autofillIds, StructureParser parser,
DisplayWarning warning, IList <InlinePresentationSpec> inlinePresentationSpecs)
{
List <Dataset> result = new List <Dataset>();
Kp2aLog.Log("AF: BuildEntryDatasets");
var suggestedEntries = GetSuggestedEntries(query).ToDictionary(e => e.DatasetName, e => e);
Kp2aLog.Log("AF: BuildEntryDatasets found " + suggestedEntries.Count + " entries");
int count = 0;
foreach (var filledAutofillFieldCollection in suggestedEntries.Values)
{
if (filledAutofillFieldCollection == null)
{
continue;
}
var inlinePresentationSpec = AutofillHelper.ExtractSpec(inlinePresentationSpecs, count);
if (warning == DisplayWarning.None)
{
FilledAutofillFieldCollection partitionData =
AutofillHintsHelper.FilterForPartition(filledAutofillFieldCollection, parser.AutofillFields.FocusedAutofillCanonicalHints);
Kp2aLog.Log("AF: Add dataset");
result.Add(AutofillHelper.NewDataset(this, parser.AutofillFields, partitionData, IntentBuilder,
inlinePresentationSpec));
}
else
{
//return an "auth" dataset (actually for just warning the user in case domain/package dont match)
IntentSender sender =
IntentBuilder.GetAuthIntentSenderForWarning(this, query, queryDomain, queryPackage, warning);
var datasetName = filledAutofillFieldCollection.DatasetName;
if (datasetName == null)
{
Kp2aLog.Log("AF: dataset name is null");
continue;
}
RemoteViews presentation =
AutofillHelper.NewRemoteViews(PackageName, datasetName, AppNames.LauncherIcon);
var datasetBuilder = new Dataset.Builder(presentation);
datasetBuilder.SetAuthentication(sender);
AutofillHelper.AddInlinePresentation(this, inlinePresentationSpec, datasetName, datasetBuilder, AppNames.LauncherIcon);
//need to add placeholders so we can directly fill after ChooseActivity
foreach (var autofillId in autofillIds)
{
datasetBuilder.SetValue(autofillId, AutofillValue.ForText("PLACEHOLDER"));
}
Kp2aLog.Log("AF: Add auth dataset");
result.Add(datasetBuilder.Build());
}
count++;
}
return(result);
}
public override void OnFillRequest(FillRequest request, CancellationSignal cancellationSignal, FillCallback callback)
{
bool isManual = (request.Flags & FillRequest.FlagManualRequest) != 0;
CommonUtil.logd("onFillRequest " + (isManual ? "manual" : "auto"));
var structure = request.FillContexts.Last().Structure;
if (_lockTime + _lockTimeout < DateTime.Now)
{
_lockTime = DateTime.Now;
//TODO support package signature verification as soon as this is supported in Keepass storage
var clientState = request.ClientState;
CommonUtil.logd("onFillRequest(): data=" + CommonUtil.BundleToString(clientState));
cancellationSignal.CancelEvent += (sender, e) =>
{
Kp2aLog.Log("Cancel autofill not implemented yet.");
_lockTime = DateTime.MinValue;
};
// Parse AutoFill data in Activity
StructureParser.AutofillTargetId query = null;
var parser = new StructureParser(this, structure);
try
{
query = parser.ParseForFill(isManual);
}
catch (Java.Lang.SecurityException e)
{
Log.Warn(CommonUtil.Tag, "Security exception handling request");
callback.OnFailure(e.Message);
return;
}
AutofillFieldMetadataCollection autofillFields = parser.AutofillFields;
InlineSuggestionsRequest inlineSuggestionsRequest = null;
IList <InlinePresentationSpec> inlinePresentationSpecs = null;
if (((int)Build.VERSION.SdkInt >= 30) &&
(PreferenceManager.GetDefaultSharedPreferences(this).GetBoolean(GetString(Resource.String.InlineSuggestions_key), true)))
{
inlineSuggestionsRequest = request.InlineSuggestionsRequest;
inlinePresentationSpecs = inlineSuggestionsRequest?.InlinePresentationSpecs;
}
var autofillIds = autofillFields.GetAutofillIds();
if (autofillIds.Length != 0 && CanAutofill(query, isManual))
{
var responseBuilder = new FillResponse.Builder();
bool hasEntryDataset = false;
IList <Dataset> entryDatasets = new List <Dataset>();
if (query.IncompatiblePackageAndDomain == false)
{
Kp2aLog.Log("AF: (query.IncompatiblePackageAndDomain == false)");
//domain and package are compatible. Use Domain if available and package otherwise. Can fill without warning.
entryDatasets = BuildEntryDatasets(query.DomainOrPackage, query.WebDomain,
query.PackageName,
autofillIds, parser, DisplayWarning.None,
inlinePresentationSpecs
).Where(ds => ds != null).ToList();
if (entryDatasets.Count > inlineSuggestionsRequest?.MaxSuggestionCount - 2 /*disable dataset and query*/)
{
//we have too many elements. disable inline suggestions
inlinePresentationSpecs = null;
entryDatasets = BuildEntryDatasets(query.DomainOrPackage, query.WebDomain,
query.PackageName,
autofillIds, parser, DisplayWarning.None,
null
).Where(ds => ds != null).ToList();
}
foreach (var entryDataset in entryDatasets
)
{
Kp2aLog.Log("AF: Got EntryDataset " + (entryDataset == null));
responseBuilder.AddDataset(entryDataset);
hasEntryDataset = true;
}
}
{
if (query.WebDomain != null)
{
AddQueryDataset(query.WebDomain,
query.WebDomain, query.PackageName,
isManual, autofillIds, responseBuilder, !hasEntryDataset,
query.IncompatiblePackageAndDomain
? DisplayWarning.FillDomainInUntrustedApp
: DisplayWarning.None,
AutofillHelper.ExtractSpec(inlinePresentationSpecs, entryDatasets.Count));
}
else
{
AddQueryDataset(query.PackageNameWithPseudoSchema,
query.WebDomain, query.PackageName,
isManual, autofillIds, responseBuilder, !hasEntryDataset, DisplayWarning.None,
AutofillHelper.ExtractSpec(inlinePresentationSpecs, entryDatasets.Count));
}
}
if (!PreferenceManager.GetDefaultSharedPreferences(this)
.GetBoolean(GetString(Resource.String.NoAutofillDisabling_key), false))
{
AddDisableDataset(query.DomainOrPackage, autofillIds, responseBuilder, isManual, AutofillHelper.ExtractSpec(inlinePresentationSpecs, entryDatasets.Count));
}
if (PreferenceManager.GetDefaultSharedPreferences(this)
.GetBoolean(GetString(Resource.String.OfferSaveCredentials_key), true))
{
if (!CompatBrowsers.Contains(parser.PackageId))
{
responseBuilder.SetSaveInfo(new SaveInfo.Builder(parser.AutofillFields.SaveType,
parser.AutofillFields.GetAutofillIds()).Build());
}
}
Kp2aLog.Log("return autofill success");
callback.OnSuccess(responseBuilder.Build());
}
else
{
Kp2aLog.Log("cannot autofill");
callback.OnSuccess(null);
}
}
else
{
Kp2aLog.Log("Ignoring onFillRequest as there is another request going on.");
}
}
public static void loge(string s)
{
Kp2aLog.Log(s);
}
// public void Save(string strFile, PwGroup pgDataSource, KdbxFormat fmt,
// IStatusLogger slLogger)
// {
// bool bMadeUnhidden = UrlUtil.UnhideFile(strFile);
//
// IOConnectionInfo ioc = IOConnectionInfo.FromPath(strFile);
// this.Save(IOConnection.OpenWrite(ioc), pgDataSource, format, slLogger);
//
// if(bMadeUnhidden) UrlUtil.HideFile(strFile, true); // Hide again
// }
/// <summary>
/// Save the contents of the current <c>PwDatabase</c> to a KDBX file.
/// </summary>
/// <param name="sSaveTo">Stream to write the KDBX file into.</param>
/// <param name="pgDataSource">Group containing all groups and
/// entries to write. If <c>null</c>, the complete database will
/// be written.</param>
/// <param name="fmt">Format of the file to create.</param>
/// <param name="slLogger">Logger that recieves status information.</param>
public void Save(Stream sSaveTo, PwGroup pgDataSource, KdbxFormat fmt,
IStatusLogger slLogger)
{
Debug.Assert(sSaveTo != null);
if (sSaveTo == null)
{
throw new ArgumentNullException("sSaveTo");
}
if (m_bUsedOnce)
{
throw new InvalidOperationException("Do not reuse KdbxFile objects!");
}
m_bUsedOnce = true;
m_format = fmt;
m_slLogger = slLogger;
PwGroup pgRoot = (pgDataSource ?? m_pwDatabase.RootGroup);
UTF8Encoding encNoBom = StrUtil.Utf8;
CryptoRandom cr = CryptoRandom.Instance;
byte[] pbCipherKey = null;
byte[] pbHmacKey64 = null;
m_pbsBinaries.Clear();
m_pbsBinaries.AddFrom(pgRoot);
List <Stream> lStreams = new List <Stream>();
lStreams.Add(sSaveTo);
HashingStreamEx sHashing = new HashingStreamEx(sSaveTo, true, null);
lStreams.Add(sHashing);
try
{
m_uFileVersion = GetMinKdbxVersion();
int cbEncKey, cbEncIV;
ICipherEngine iCipher = GetCipher(out cbEncKey, out cbEncIV);
m_pbMasterSeed = cr.GetRandomBytes(32);
m_pbEncryptionIV = cr.GetRandomBytes((uint)cbEncIV);
// m_pbTransformSeed = cr.GetRandomBytes(32);
PwUuid puKdf = m_pwDatabase.KdfParameters.KdfUuid;
KdfEngine kdf = KdfPool.Get(puKdf);
if (kdf == null)
{
throw new Exception(KLRes.UnknownKdf + MessageService.NewParagraph +
// KLRes.FileNewVerOrPlgReq + MessageService.NewParagraph +
"UUID: " + puKdf.ToHexString() + ".");
}
kdf.Randomize(m_pwDatabase.KdfParameters);
if (m_format == KdbxFormat.Default)
{
if (m_uFileVersion < FileVersion32_4)
{
m_craInnerRandomStream = CrsAlgorithm.Salsa20;
m_pbInnerRandomStreamKey = cr.GetRandomBytes(32);
}
else // KDBX >= 4
{
m_craInnerRandomStream = CrsAlgorithm.ChaCha20;
m_pbInnerRandomStreamKey = cr.GetRandomBytes(64);
}
m_randomStream = new CryptoRandomStream(m_craInnerRandomStream,
m_pbInnerRandomStreamKey);
}
if (m_uFileVersion < FileVersion32_4)
{
m_pbStreamStartBytes = cr.GetRandomBytes(32);
}
Stream sXml;
if (m_format == KdbxFormat.Default || m_format == KdbxFormat.ProtocolBuffers)
{
byte[] pbHeader = GenerateHeader();
m_pbHashOfHeader = CryptoUtil.HashSha256(pbHeader);
MemUtil.Write(sHashing, pbHeader);
sHashing.Flush();
ComputeKeys(out pbCipherKey, cbEncKey, out pbHmacKey64);
Stream sPlain;
if (m_uFileVersion < FileVersion32_4)
{
Stream sEncrypted = EncryptStream(sHashing, iCipher,
pbCipherKey, cbEncIV, true);
if ((sEncrypted == null) || (sEncrypted == sHashing))
{
throw new SecurityException(KLRes.CryptoStreamFailed);
}
lStreams.Add(sEncrypted);
MemUtil.Write(sEncrypted, m_pbStreamStartBytes);
sPlain = new HashedBlockStream(sEncrypted, true);
}
else // KDBX >= 4
{
// For integrity checking (without knowing the master key)
MemUtil.Write(sHashing, m_pbHashOfHeader);
byte[] pbHeaderHmac = ComputeHeaderHmac(pbHeader, pbHmacKey64);
MemUtil.Write(sHashing, pbHeaderHmac);
Stream sBlocks = new HmacBlockStream(sHashing, true,
true, pbHmacKey64);
lStreams.Add(sBlocks);
sPlain = EncryptStream(sBlocks, iCipher, pbCipherKey,
cbEncIV, true);
if ((sPlain == null) || (sPlain == sBlocks))
{
throw new SecurityException(KLRes.CryptoStreamFailed);
}
}
lStreams.Add(sPlain);
if (m_pwDatabase.Compression == PwCompressionAlgorithm.GZip)
{
sXml = new GZipStream(sPlain, CompressionMode.Compress);
lStreams.Add(sXml);
}
else
{
sXml = sPlain;
}
if (m_uFileVersion >= FileVersion32_4)
{
WriteInnerHeader(sXml); // Binary header before XML
}
}
else if (m_format == KdbxFormat.PlainXml)
{
sXml = sHashing;
}
else
{
Debug.Assert(false);
throw new ArgumentOutOfRangeException("fmt");
}
var stopWatch = Stopwatch.StartNew();
if (m_format == KdbxFormat.ProtocolBuffers)
{
KdbpFile.WriteDocument(m_pwDatabase, sXml, m_pbInnerRandomStreamKey, m_pbHashOfHeader);
}
else
{
#if KeePassUAP
XmlWriterSettings xws = new XmlWriterSettings();
xws.Encoding = encNoBom;
xws.Indent = true;
xws.IndentChars = "\t";
xws.NewLineOnAttributes = false;
XmlWriter xw = XmlWriter.Create(sXml, xws);
#else
XmlTextWriter xw = new XmlTextWriter(sXml, encNoBom);
xw.Formatting = Formatting.Indented;
xw.IndentChar = '\t';
xw.Indentation = 1;
#endif
m_xmlWriter = xw;
WriteDocument(pgRoot);
m_xmlWriter.Flush();
m_xmlWriter.Close();
}
Kp2aLog.Log(String.Format("{1}: {0}ms", stopWatch.ElapsedMilliseconds, m_format == KdbxFormat.ProtocolBuffers ? "KdbpFile.WriteDocument" : "Xml WriteDocument"));
}
finally
{
if (pbCipherKey != null)
{
MemUtil.ZeroByteArray(pbCipherKey);
}
if (pbHmacKey64 != null)
{
MemUtil.ZeroByteArray(pbHmacKey64);
}
CommonCleanUpWrite(lStreams, sHashing);
}
}
public IDriveItemRequestBuilder getPathItem()
{
Kp2aLog.Log("getPathItem for " + itemLocation.ToString());
IDriveItemRequestBuilder pathItem;
if (!hasShare())
{
throw new Exception("Cannot get path item without share");
}
if ("me".Equals(itemLocation.Share.Id))
{
if (verbose)
{
Kp2aLog.Log("Path share is me");
}
if (_specialFolder == null)
{
if (verbose)
{
Kp2aLog.Log("No special folder. Use drive root.");
}
pathItem = client.Me.Drive.Root;
}
else
{
if (verbose)
{
Kp2aLog.Log("Special folder = " + _specialFolder);
}
pathItem = client.Me.Drive.Special[_specialFolder];
}
if (itemLocation.LocalPath.Any())
{
if (verbose)
{
Kp2aLog.Log("LocalPath = " + itemLocation.LocalPathString);
}
pathItem = pathItem.ItemWithPath(itemLocation.LocalPathString);
}
}
else
{
if (verbose)
{
Kp2aLog.Log("Path share is not me");
}
if (!itemLocation.LocalPath.Any())
{
String webUrl = itemLocation.Share.WebUrl;
if (verbose)
{
Kp2aLog.Log("Share WebUrl = " + webUrl);
}
var encodedShareId = CalculateEncodedShareId(webUrl);
return(client.Shares[encodedShareId].Root);
}
/*String webUrl = itemLocation.Share.WebUrl;
* if ("".Equals(itemLocation.LocalPath) == false)
* {
* if (!webUrl.EndsWith("/")) webUrl += "/";
* webUrl += itemLocation.LocalPath;
* }
* Android.Util.Log.Debug("KP2A","webUrl = " + Encoding.UTF8.GetBytes(webUrl));
* //calculate shareid according to https://docs.microsoft.com/en-us/graph/api/shares-get?view=graph-rest-1.0&tabs=java
* var encodedShareId = CalculateEncodedShareId(webUrl);
* Android.Util.Log.Debug("KP2A", "encodedShareId = " + encodedShareId);
* pathItem = client.Shares[encodedShareId].Root;
*/
if (verbose)
{
Kp2aLog.Log("Using driveId=" + itemLocation.DriveId + " and item id=" + itemLocation.LocalPath.Last().Id);
}
return(client.Drives[itemLocation.DriveId].Items[itemLocation.LocalPath.Last().Id]);
}
return(pathItem);
}
public void TestLoadEditSaveWhenModified()
{
//create the default database:
IKp2aApp app = SetupAppWithDefaultDatabase();
IOConnection.DeleteFile(new IOConnectionInfo {
Path = DefaultFilename
});
//save it and reload it so we have a base version
SaveDatabase(app);
app = LoadDatabase(DefaultFilename, DefaultPassword, DefaultKeyfile);
foreach (var group in app.GetDb().KpDatabase.RootGroup.Groups)
{
Kp2aLog.Log("app c: " + group.Name);
}
//load once more:
var app2 = LoadDatabase(DefaultFilename, DefaultPassword, DefaultKeyfile);
//modifiy once:
PwGroup group2 = new PwGroup(true, true, "TestGroup2", PwIcon.Apple);
app2.GetDb().KpDatabase.RootGroup.AddGroup(group2, true);
foreach (var group in app.GetDb().KpDatabase.RootGroup.Groups)
{
Kp2aLog.Log("app b: " + group.Name);
}
SaveDatabase(app2);
_testCacheSupervisor.Reset();
foreach (var group in app.GetDb().KpDatabase.RootGroup.Groups)
{
Kp2aLog.Log("app d: " + group.Name);
}
Assert.IsNull(((TestKp2aApp)app).LastYesNoCancelQuestionTitle);
_testCacheSupervisor.AssertNoCall();
//modify the database by adding a group:
PwGroup group1 = new PwGroup(true, true, "TestGroup", PwIcon.Apple);
app.GetDb().KpDatabase.RootGroup.AddGroup(group1, true);
foreach (var group in app.GetDb().KpDatabase.RootGroup.Groups)
{
Kp2aLog.Log("app a: " + group.Name);
}
//save the database again:
_testCacheSupervisor.Reset();
SaveDatabase(app);
Assert.AreEqual(((TestKp2aApp)app).LastYesNoCancelQuestionTitle, UiStringKey.TitleSyncQuestion);
_testCacheSupervisor.AssertNoCall();
//load database to a new app instance:
IKp2aApp resultApp = LoadDatabase(DefaultFilename, DefaultPassword, DefaultKeyfile);
app2.GetDb().KpDatabase.RootGroup.AddGroup(group1, true);
foreach (var group in app.GetDb().KpDatabase.RootGroup.Groups)
{
Kp2aLog.Log("app: " + group.Name);
}
foreach (var group in resultApp.GetDb().KpDatabase.RootGroup.Groups)
{
Kp2aLog.Log("resultApp: " + group.Name);
}
//ensure the change was saved:
AssertDatabasesAreEqual(app2.GetDb().KpDatabase, resultApp.GetDb().KpDatabase);
}
private static IOWebClient CreateWebClient(IOConnectionInfo ioc, bool digestAuth)
{
PrepareWebAccess();
IOWebClient wc = new IOWebClient();
ConfigureWebClient(wc);
if ((ioc.UserName.Length > 0) || (ioc.Password.Length > 0))
{
//set the credentials without a cache (in case the cache below fails:
//check for backslash to determine whether we need to specify the domain:
int backslashPos = ioc.UserName.IndexOf("\\", StringComparison.Ordinal);
if (backslashPos > 0)
{
string domain = ioc.UserName.Substring(0, backslashPos);
string user = ioc.UserName.Substring(backslashPos + 1);
wc.Credentials = new NetworkCredential(user, ioc.Password, domain);
}
else
{
wc.Credentials = new NetworkCredential(ioc.UserName, ioc.Password);
}
if (digestAuth)
{
//try to use the credential cache to access with Digest support:
try
{
var credentialCache = new CredentialCache();
credentialCache.Add(
new Uri(new Uri(ioc.Path).GetLeftPart(UriPartial.Authority)),
"Digest",
new NetworkCredential(ioc.UserName, ioc.Password)
);
credentialCache.Add(
new Uri(new Uri(ioc.Path).GetLeftPart(UriPartial.Authority)),
"NTLM",
new NetworkCredential(ioc.UserName, ioc.Password)
);
wc.Credentials = credentialCache;
} catch (NotImplementedException e)
{
Kp2aLog.Log(e.ToString());
} catch (Exception e)
{
Kp2aLog.LogUnexpectedError(e);
Debug.Assert(false);
}
}
}
else if (NativeLib.IsUnix()) // Mono requires credentials
{
wc.Credentials = new NetworkCredential("anonymous", string.Empty);
}
return(wc);
}
public void SetMessage(string resourceString)
{
Kp2aLog.Log("Progress message: " + resourceString);
}
